unorderedSet


template <class T>
class unorderedSet : public Semaphore
{
 public:

  // *** typedefs ***

  typedef Integer (*typeHash)(const T&);

  typedef bool (*typeCompare)(const T&,const T&);

  // *** iterators ***

  typedef unorderedSetIterator<T> iterator;

  typedef constUnorderedSetIterator<T> const_iterator;

  // *** Constructors, Destructor and Operators ***

  unorderedSet(typeHash H=hasher,
               typeCompare C=equality_compare);

  unorderedSet(const unorderedSet<T>& Copy);

  unorderedSet(const unorderedSet& A,
               const unorderedSet& B,
               Unsigned Operation);

  template<class I>
  unorderedSet(I first,
               I last,
               typeHash H=hasher<T>,
               typeCompare C=equality_compare<T>);

  ~unorderedSet();

  unorderedSet<T>& operator=(const unorderedSet<T>& copy);

  bool operator[](const T& Key) const;

  void* operator new(size_t s);

  void operator delete(void* p);

  operator typeCompare() const;

  operator typeHash() const;

  unorderedSet<T>& operator<<(const T& Element);

  unorderedSet<T>& operator>>(const T& Element);

  // *** Methods ***

  iterator begin();

  iterator end();

  const_iterator begin() const;

  Unsigned depth() const; 

  const_iterator end() const;

  void erase();

  void erase(const T& Element);

  void erase(iterator i);

  bool exists(const T& Key) const;

  iterator find(const T& Key) const;

  Integer hash() const;

  iterator insert(const T& Element);

  iterator last();

  const_iterator last() const;

  Unsigned length() const;
};

//*** Set Theoretic Operators ***

template<class T>
inline unorderedSet<T> operator|(const unorderedSet<T>& a,const unorderedSet<T>& b);

template<class T>
inline unorderedSet<T> operator&(const unorderedSet<T>& a,const unorderedSet<T>& b);

template<class T>
inline unorderedSet<T> operator^(const unorderedSet<T>& a,const unorderedSet<T>& b);

template<class T>
inline unorderedSet<T> operator-(const unorderedSet<T>& a,const unorderedSet<T>& b);

template<class T>
inline bool operator==(const unorderedSet<T>& a,const unorderedSet<T>& b);

template<class T>
inline bool operator!=(const unorderedSet<T>& a,const unorderedSet<T>& b);

template<class T>
inline bool operator<=(const unorderedSet<T>& a,const unorderedSet<T>& b);