#ifndef __DEQUE_HPP
#define __DEQUE_HPP

template<class Item>
class Deque {
public:
        Deque() : firstIterator(0) {}
        virtual ~Deque() {}

        virtual void putLeft(const Item &i) =0;
        virtual Item getLeft() =0;
        virtual Item peekLeft() const =0;
        virtual void putRight(const Item &i) =0;
        virtual Item getRight() =0;
        virtual Item peekRight() const =0;

        virtual int isEmpty() const =0;
        virtual unsigned length() const =0;

private:
        QueueIterator<Item> *firstIterator;
protected:
        void cleared();
        void itemInserted(unsigned before);
        void itemAppended(unsigned after);
        void itemRemoved(unsigned at, unsigned ql);

        friend class DequeIterator<Item>;
        class DLock {
                Deque<Item> *d;
        public: DLock(const Deque<Item> *deque) : d((Deque<Item>*)deque) { d->lock(); }
                ~DLock() { d->unlock(); }
        };

        friend class DLock;
        virtual lock() {}
        virtual unlock() {}

};

template<class Item>
class DequeIterator {
        DequeIterator(const DequeIterator<Item>&);     //dont copy
        operator=(const DequeIterator<Item>&);         //dont copy
public:
        DequeIterator(const Deque<Item> &queue);
        virtual ~DequeIterator();

        virtual int isDone();
        virtual const Item* currentItem();
        virtual int advance();
        virtual void reset();

private:
        DequeIterator<Item> *prev,*next;
        const Deque<Item> &d;
        int currentIndex,nextIndex;

        friend class Deque<Item>;
        void dequeCleared();
        void dequeItemInserted(unsigned before);
        void dequeItemAppended(unsigned after);
        void dequeItemRemoved(unsigned at, unsigned ql);
};


#include "deque.cpp"

#endif