#ifndef RBUFFER_H_
#define RBUFFER_H_

/**
 * @file: RBuffer.h \brief Ringbuffer as template class
 *
 * \ingroup avr_tools
 * Implements a simple ringbuffer 
 */

#include "libavr/globals.h"

template < class IndexType, unsigned Size, class EntryType >
/**
 * Template class for a ringbuffer. The buffer index, the type of
 * the buffered data and the buffer size can be defined.
 * 
 * Instantiate via: RBuffer <u08, 4, char) Buffer for a ringbuffer
 * with an index of type u08, a size of 4 elements and for data
 * elements of type char.
 */ 
class RBuffer {

public:
	/**
	 * Default constructor
	 */
	RBuffer() {
		m_putIndex = 0;
		m_isFull = false;
	}
	
	/**
	 * Returns the number of objects in the ringbuffer. The returned 
	 * object is of type IndexType.
	 */
	IndexType getObjCount() const {
		if (m_isFull) {
			return Size;
		}			
		return m_putIndex;
	}
	
	/**
	 * Returns the size of the ringbuffer, i. e. the maximum 
	 * number of elements in the buffer. The returned object
	 * is of type IndexType.
	 */
	IndexType getSize() const {
		return Size;
	}
		
	/**
	 * Returns true if the buffer is empty. False otherwise
	 */
	bool isEmpty() const {
		if (!m_isFull & (m_putIndex==0)) {
			return  true;
		}
		return false;
	}
	
	/**
	 * Returns true if the buffer is full. False otherwise
	 */
	bool isFull() const { 
		return m_isFull;
	}

	/**
	 * Pushes an object on the ringbuffer. The new object is inserted
	 * after the last current object. Any present object in this location
	 * is overwritten.
	 */		
	void pushObj(EntryType obj) {
		m_buffer[m_putIndex] = obj;
		m_putIndex++;
		if (m_putIndex == Size) {
			m_isFull = true;
			m_putIndex = 0;
		}
	}
	
	/**
	 * Returns the object at the index position provided
	 */
	EntryType getObjAtIndex(unsigned position) {
		return m_buffer[position];				
	}
	
	/**
	 * Returns the object <position> elements from the newest object. 
	 * Note that you are not able to retrieve more than the number
	 * of elements on the buffer. This has to be checked in the
	 * application code. 
	 */
	EntryType getObjFromNewest(unsigned position) {
		IndexType idx;
		idx = m_putIndex - 1 - position + Size;
		idx = idx % Size;
		return m_buffer[idx];
	}
	
	/*
	 * Returns the current position of the index
	 */
	IndexType getCurrentIndex() {
		return (m_putIndex - 1 + Size) % Size; 	
	}
	
	/*
	 * Clears the buffer and resets all indexes etc.
	 */
	void clear() {
		m_buffer = m_buffer[Size];
		m_isFull = false;
		m_putIndex = 0;		
	}
	
private:
	// n is the last element in the buffer; m_putIndex points to n+1
	volatile bool 		m_isFull;
	volatile IndexType  m_putIndex;
    volatile EntryType  m_buffer[ Size ];

};

#endif /*RBUFFER_H_*/