template 
RoundRobin::RoundRobin(int numExpected)
{
  // If the client gave a guideline, reserve that much space.
  mElems.reserve(numExpected);

  // Initialize mCurElem even though it isn't used until
  // there's at least one element.
  mCurElem = mElems.begin();
}

template 
RoundRobin::~RoundRobin()
{
  // nothing to do here -- the vector will delete all the elements
}

//
// Always add the new element at the end
//
template 
void RoundRobin::add(const T& elem)
{
  //
  // Even though we add the element at the end,
  // the vector could reallocate and invalidate the iterator.
  // Take advantage of the random access iterator features to save our
  // spot.
  //
  int pos = mCurElem - mElems.begin();

  // add the element
  mElems.push_back(elem);

  // If it's the first element, initialize the iterator to the beginning
  if (mElems.size() == 1) { 
    mCurElem = mElems.begin();
  } else {
    // set it back to our spot
    mCurElem = mElems.begin() + pos;
  }
}

template 
void RoundRobin::remove(const T& elem)
{
  for (typename std::vector::iterator it = mElems.begin(); it != mElems.end(); ++it) {
    if (*it == elem) {
      //
      // Removing an element will invalidate our mCurElem iterator if
      // it refers to an element past the point of the removal.
      // Take advantage of the random access features of the iterator
      // to track the position of the current element after the removal.
      //
      int newPos;

      // If the current iterator is before or at the one we're removing,
      // the new position is the same as before.
      if (mCurElem <= it) {
        newPos = mCurElem - mElems.begin();
      } else {
        // otherwise, it's one less than before
        newPos = mCurElem - mElems.begin() - 1;
      }
      // erase the element (and ignore the return value)
      mElems.erase(it);

      // Now reset our iterator
      mCurElem = mElems.begin() + newPos;

      // If we were pointing to the last element and it was removed,
      // we need to loop back to the first.
      if (mCurElem == mElems.end()) {
        mCurElem = mElems.begin();
      }
      return;
    }
  }
}

template 
T& RoundRobin::getNext()throw(std::out_of_range)
{
  // First, make sure there are any elements.
  if (mElems.empty()) {
    throw std::out_of_range("No elements in the list");
  }

  // retrieve a reference to return
  T& retVal = *mCurElem;

  // Increment the iterator modulo the number of elements
  ++mCurElem;
  if (mCurElem == mElems.end()) {
    mCurElem = mElems.begin();
  }

  // return the reference
  return (retVal);
}