#ifndef __SET_HPP
#define __SET_HPP

template<class Item>
class Set {
        //prevent compiler-generated copy ctor
        Set(const Set<Item>&); //not implemented
public:
        Set() {}
        virtual ~Set() {}

        //operators
        Set<Item>& operator=(const Item &item)    { assign(item); return *this; }
        Set<Item>& operator=(const Set<Item> &s)  { assign(s); return *this; }
        Set<Item>& operator+=(const Item &item)   { setUnion(item); return *this; }
        Set<Item>& operator+=(const Set<Item> &s) { setUnion(s); return *this; }
        Set<Item>& operator-=(const Item &item)   { setDifference(item); return *this; }
        Set<Item>& operator-=(const Set<Item> &s) { setDifference(s); return *this; }
        Set<Item>& operator*=(const Item &item)   { setIntersection(item); return *this; }
        Set<Item>& operator*=(const Set<Item> &s) { s.setIntersetionTo(*this); return *this; }

        int operator==(const Set<Item> &s) const  { return s.equalTo(*this); }
        int operator!=(const Set<Item> &s) const  { return s.notequalTo(*this; }
        int operator<=(const Set<Item> &s) const  { return s.subsetTo(*this); }
        int operator>=(const Set<Item> &s) const  { return s.supersetTo(*this); }
        int operator<(const Set<Item> &s) const   { return s.propersubsetTo(*this); }
        int operator>(const Set<Item> &s) const   { return s.propersupersetTo(*this); }

        //non-operators
        virtual int isEmpty() const                            =0;
        virtual unsigned length() const                        =0;
        virtual void clear()                                   =0;
        virtual int contains(const Item &item) const           =0;

protected:
        //remapped operators (for locking purposes)
        virtual void assign(const Item &i)                     =0;
        virtual void assign(const Set<Item> &s)                { clear(); s.assignTo(*this); }
        virtual void assignTo(Set<Item> &s) const              =0;
        virtual void setUnion(const Item &item)                =0;
        virtual void setUnion(const Set<Item> &s)              { s.setUnionTo(*this); }
        virtual void setUnionTo(Set<Item> &s) const            =0;
        virtual void setDifference(const Item &item)           =0;
        virtual void setDifference(const Set<Item> &s)         { s.setDifferenceTo(*this); }
        virtual void setDifferenceTo(Set<Item> &s) const       =0;
        virtual void setIntersection(const Item &item)         =0;
        virtual void setIntersection(const Set<Item> &s)       =0;
        virtual void setIntersectionTo(Set<Item> &s) const     { s.setIntersection(*this); }

        virtual int equal(const Set<Item> &s) const            =0;
        virtual int equalTo(const Set<Item> &s) const          { return s.equal(*this); }
        virtual int notequal(const Set<Item> &s) const         =0;
        virtual int notequalTo(const Set<Item> &s) const       { return s.notequal(*this); }
        virtual int subset(const Set<Item> &s) const           =0;
        virtual int subsetTo(const Set<Item> &s) const         { return s.subset(*this); }
        virtual int superset(const Set<Item> &s) const         =0;
        virtual int supersetTo(const Set<Item> &s) const       { return s.superset(*this); }
        virtual int propersubset(const Set<Item> &s) const     =0;
        virtual int propersubsetTo(const Set<Item> &s) const   { return s.propersubset(*this); }
        virtual int propersuperset(const Set<Item> &s) const   =0;
        virtual int propersupersetTo(const Set<Item> &s) const { return s.propersuperset(*this); }

//cursor management
protected:
        class Cursor_rep {
        public:
                virtual ~Cursor_rep() {}
                virtual int isDone() const =0;
                virtual const Item& currentItem() const =0;
                virtual void advance() =0;
        };

public:
        class Cursor {
                Cursor_rep *rep;
        public:
                Cursor(const Stack<Item> &s)
                  : rep(s.makeCursorRep())
                  {}
                ~Cursor() { delete rep; }
                int isDone() const { return rep->isDone(); }
                const Item& currentItem() const { return rep->currentItem(); }
                void advance() { rep->advance(); }
        };

protected:
        virtual Cursor_rep *makeCursorRep() const =0;
        friend class Cursor; //needs to call the function above
};

#endif //__SET_HPP