#ifndef AG_SET_H
#define AG_SET_H

/*
 * The AGCLIB1 Class Library, Version 1.0
 * Copyright (c) Parsifal Software, 2001. All Rights Reserved.
 * http://www.parsifalsoft.com
*/

#include "agbset.h"

template <class Object>
class AgSet
: public AgCopyControl<AgSetBase<Object> >
{
  typedef AgSetBase<Object>          SetBase;
  typedef AgCopyControl<SetBase>     Base;
  typedef AgSet<Object>              This;
public:
  typedef AgContents<Object, Base>   Contents;
  AgSet() : Base(new SetBase()) {}
  AgSet(const AgContainerContents<Object> &x) : Base(new AgSetBase<Object>(x)) {}
  AgSet(const This &s) : Base(s) {}
  ~AgSet() {}

  const Object *add(const Object &object) {return kernel()->add(object);}
  int remove(const Object &object) {return kernel()->remove(object);}

  Object *contains(const Object &e) {return kernel()->contains(e);}
  const Object *contains(const Object &e) const {return kernel()->contains(e);}

  int size() const {return kernel()->size();}

  AgSet<Object> &reset() {kernel()->reset(); return *this;}

  const Contents contents() const {return Contents(*this);}

  This &operator = (const This &x) {Base::operator = (x); return *this;}
  This &operator = (const AgContainerContents<Object> &x) {*kernel() = x; return *this;}

  Object &operator [] (int x) {return kernel()->operator [] (x);}
  const Object &operator [] (int x) const {return kernel()->operator [] (x);}

  int operator <= (const AgSet<Object> &x) const {return *kernel() <= *x.kernel();}
  int operator >= (const AgSet<Object> &x) const {return *kernel() >= *x.kernel();}
  int operator < (const AgSet<Object> &x) const {return *kernel() < *x.kernel();}
  int operator > (const AgSet<Object> &x) const {return *kernel() > *x.kernel();}
//  int operator == (const AgSet<Object> &x) const {return *kernel() == *x.kernel();}
//  int operator != (const AgSet<Object> &x) const {return *kernel() != *x.kernel();}

#ifdef TESTING_AG_SET
  int maxDepth() const {return kernel()->maxDepth();}
  double avgDepth() const {return kernel()->avgDepth();}
#endif
};

// Definition of set union
template <class Object, class Container>
AgSet<Object> &operator += (AgSet<Object> &dest, const Container &source) {
  int n = source.size();
  for (int i = 0; i < n; i++) dest.add((Object &) source[i]);
  return dest;
}

template <class Object, class Container>
AgSet<Object> operator + (const AgSet<Object> &x, const Container &y) {
  AgSet<Object> result = x;
  return result += y;
}

// Definition of set difference
template <class Object, class Container>
AgSet<Object> &operator -= (AgSet<Object> &dest, const Container &source) {
  int i, n = source.size();
  for (i = 0; i < n; i++) dest.remove((Object &) source[i]);
  return dest;
}

template <class Object, class Container>
AgSet<Object> operator -(const AgSet<Object> &x, const Container &y) {
  AgSet<Object> result = x;
  return result -= y;
}

// Definition of set intersection
template <class Object, class Container>
AgSet<Object> operator *(const AgSet<Object> &x, const Container &y) {
  AgSet<Object> result;
  int n = y.size();
  while (n--) {
    const Object &object = y[n];
    if (x.contains(object)) result.add(object);
  }
  return result;
}

template <class Object, class Container>
AgSet<Object> &operator *= (AgSet<Object> &dest, const Container &source) {
  return dest = dest * source;
}

// Subset operators
// x >= y is true if and only if x contains all the elements of y
template <class Object, class Container>
int operator >= (const AgSet<Object> &x, const Container &y) {
  int n = y.size();
  while (n--) if (!x.contains(y[n])) return 0;
  return 1;
}

template <class Object>
int agABTHash(const AgSet<Object> &c, int startValue) {
  return agABTHash(c.kernel()->hash(), startValue);
}

template <class Object>
int agABTHash(const AgSet<Object> &c) {
  return agABTHash(c, 0);
}

#endif