// tell emacs we are using -*- C++ -*-
//

#ifndef SET_H
#define SET_H

#include "../lib/list.h"
#include <iostream.h>

template <class T>
class set
{
public:
  // constructors
  set();
  set(set<T> & old);

  // operations
  set<T> insert(T item);
  set<T> setunion(const set<T> & right);
  set<T> intersect(const set<T> & right);
  set<T> difference(const set<T> & right);
  int member(T item) const;
  set<T> & operator = (const set<T> & right);

  int size();
  void makeEmpty();
  
  // friends
  friend istream & operator >> <> (istream & stream, set<T> & right);  
  friend ostream & operator << <> (ostream & stream, const set<T> & right);

protected:
  list<T> contents;
};

// basic constructor

template <class T>
set<T>::set ()
{
}

// the copy constructor
template <class T>
set<T>::set (set<T> & old): contents(old.contents)
{
}

template <class T>
void set<T>::makeEmpty ()
{
  contents.deleteAllValues();
}

// insert an item into the set.  
template <class T>
set<T> set<T>::insert(T item)
{
  // only add item if it is not already there.
  if (!member(item)) {
    contents.add(item);
  }
  return *this;
}

// Create a new set that is the union of two given sets.
template <class T>
set<T> set<T>::setunion(const set<T> & right)
{
  // copy the current set
  set<T> result(*this);
  // the cast to (list<T>&) removes the "const"-ness of right
  // We are promising that we will not use the iterator to modify
  // right.contents. 
  listIterator<T> itr((list<T>&)(right.contents));
  for (itr.init(); !itr; ++itr) {
    result.insert(itr());
  }
  return result;
}

// Create a new set that is the intersection of two given sets
template <class T>
set<T> set<T>::intersect(const set<T> & right)
{
  // Create an empty result.
  set<T> result;
  
  listIterator<T> itr(contents);
  for (itr.init(); !itr; ++itr) {
    if (right.member(itr())) {
      result.insert(itr());
    }
  }
  return result;
}

// Create a new set that contains all elements of *this that are not
// in right.
template <class T>
set<T> set<T>::difference(const set<T> & right)
{
  // Create an empty result.
  set<T> result;
  
  listIterator<T> itr(contents);
  for (itr.init(); !itr; ++itr) {
    if (!right.member(itr())) {
      result.insert(itr());
    }
  }
  return result;
}

template <class T>
int set<T>::member (T item) const
{
  return contents.includes(item);
}

template <class T>
int set<T>::size ()
{
  return contents.length();
}

// The assignment operator.  We must do a deep copy of the contents
// field. 
template <class T>
set<T> & set<T>::operator = (const set<T> & right)
{
  // list assignment does the deep copy for us.
  contents = right.contents;
}


// I/O operations

template <class T>
istream & operator >> (istream & stream, set<T> & right)
{
  right.makeEmpty();
  char c;
  stream >> c;
  assert(c == '{');
  while (1) {
    stream >> c;
    if (c == '}') break;
    T temp;
    stream >> temp;
    right.insert(temp);
  }
  return stream;
}

template <class T>
ostream & operator << (ostream & stream, const set<T> & right)
{
  stream << "{";
  // the cast to (list<T>&) removes the "const"-ness of right
  // We are promising that we will not use the iterator to modify
  // right.contents. 
  listIterator<T> itr((list<T>&)(right.contents));
  itr.init();
  while (!itr) {
    stream << itr();
    ++itr;
    // if there is another element, print a space first.
    if (!itr) stream << " ";
  }
  stream << "}";
  return stream;
}  



#endif