#include <algorithm>
#include <iterator>
#include <iostream>
#include "RingBuffer.h"

using namespace std;

// Microsoft Visual Studio requires you to omit the following line.
// However, some compilers require it.
//const int RingBuffer::kDefaultNumEntries;

//
// Initialize the vector to hold exactly numEntries. The vector size
// does not need to change during the lifetime of the object.
//
// Initialize the other members.
//
RingBuffer::RingBuffer(int numEntries, ostream* ostr) : mEntries(numEntries),
							mOstr(ostr), mNumEntries(numEntries), mNext(0), mWrapped(false)
{
}

RingBuffer::~RingBuffer()
{
}

//
// The algorithm is pretty simple: add the entry to the next
// free spot, then reset mNext to indicate the free spot after
// that. If mNext reaches the end of the vector, it starts over at 0.
//
// The buffer needs to know if the buffer has wrapped or not so
// that it knows whether to print the entries past mNext in operator<<
//
void RingBuffer::addEntry(const string& entry)
{
  // Add the entry to the next free spot and increment
  // mNext to point to the free spot after that.
  mEntries[mNext++] = entry;

  // Check if we've reached the end of the buffer. If so, we need to wrap.
  if (mNext >= mNumEntries) {
    mNext = 0;
    mWrapped = true;
  }

  // If there is a valid ostream, write this entry to it.
  if (mOstr != NULL) {
    *mOstr << entry << endl;
  }
}

ostream* RingBuffer::setOutput(ostream* newOstr)
{
  ostream* ret = mOstr;
  mOstr = newOstr;
  return (ret);
}

//
// This function uses an ostream_iterator to "copy" entries directly
// from the vector to the output stream.
//
// This function must print the entries in order. If the buffer has wrapped,
// the earliest entry is one past the most recent entry, which is the entry
// indicated by mNext. So first print from entry mNext to the end.
//
// Then (even if the buffer hasn't wrapped) print from the beginning to mNext - 1.
//
ostream& operator<<(ostream& ostr, const RingBuffer& rb)
{
  if (rb.mWrapped) {
    //
    // If the buffer has wrapped, print the elements from
    // the earliest entry to the end.
    //
    copy (rb.mEntries.begin() + rb.mNext, rb.mEntries.end(),
	  ostream_iterator<string>(ostr, "\n"));
  }

  //
  // Now print up to the most recent entry.
  // Go up to begin() + mNext because the range is not inclusive on the
  // right side.
  //
  copy (rb.mEntries.begin(), rb.mEntries.begin() + rb.mNext,
        ostream_iterator<string>(ostr, "\n"));

  return (ostr);
}