#ifndef __SYNCHRONIZEDSTACK_HPP
#define __SYNCHRONIZEDSTACK_HPP

#include "boundedstack.hpp"

template<class Item, unsigned Size, class Monitor>
class SynchronizedBoundedStack : public BoundedStack<Item,Size> {
public:
        SynchronizedBoundedStack() {}
        SynchronizedBoundedStack(const Stack<Item> &s);

        SynchronizedBoundedStack<Item,Size,Monitor>& operator=(const Stack<Item> &s);

        void push(const Item &i);
        Item pop();
        Item top() const;
        int isEmpty() const;
        unsigned length() const;
        void clear();

protected:
        void copy(const Stack<Item> &s);
        void copyTo(Stack<Item> &s) const;

protected:
        Monitor monitor;
        class ReadLock {
                SynchronizedBoundedStack<Item,Size,Monitor> *s;
        public:
                ReadLock(const SynchronizedBoundedStack<Item,Size,Monitor> *stack);
                ~ReadLock();
        };
        friend class ReadLock;
        class WriteLock {
                SynchronizedBoundedStack<Item,Size,Monitor> *s;
        public:
                WriteLock(SynchronizedBoundedStack<Item,Size,Monitor> *stack);
                ~WriteLock();
        };
        friend class WriteLock;

        Cursor_rep *makeCursorRep() const;
        int cursor_isDone(const BCursor_rep *c) const;
        const Item& cursor_currentItem(const BCursor_rep *c) const;
        void cursor_advance(BCursor_rep *c) const;
        void cursor_unlink(BCursor_rep *c) const;
};


#include "synchronizedboundedstack.cpp"

#endif