circularbuffers.h

Go to the documentation of this file.

 
#include "elementa/license.inc"
#include "elementa/checks.inc"
 
#ifndef ELEMENTA_ADTS_CIRCULARBUFFER_H
#define ELEMENTA_ADTS_CIRCULARBUFFER_H
 
 
#include <vector>
#include "elementa/base/exceptions.h"
 
 
namespace elementa
{
 
namespace adts
{
 
/* ***************************************************************************
 
    Template class: CircularBuffer
    
*******************************************************************************/
 
 
template <typename ElemType>
class CircularBuffer
{
 public:
 
 
 
    CircularBuffer(size_t s);
    
    
 
    void clear(void) { initpos_ = 0; size_ = 0; }
    
    size_t capacity(void) const noexcept { return(capacity_); }
    
    size_t size(void) const noexcept { return(size_); }
    
    bool empty(void) const noexcept { return(size_ == 0); }
    
 
    ElemType & back(void);
    
 
    void push_back(const ElemType & e);
    
 
    ElemType & front(void);
    
 
    void pop_front(void);
    
    
    ElemType & operator[](size_t index);
    
    
 private:
 
    const size_t capacity_;
    std::vector<ElemType> storage_;
    size_t initpos_,size_;
    
    constexpr size_t index(size_t i) noexcept 
        { return((initpos_ + i) % capacity_); }
};
 
 
 
/* ===========================================================================
 
        ========== IMPLEMENTATION OF TEMPLATES ==========
 
============================================================================= */
 
 
/* ***************************************************************************
 
    Template class: CircularBuffer
    
*******************************************************************************/
 
template <typename ElemType>
CircularBuffer<ElemType>::CircularBuffer(size_t s): capacity_{s},
                                                    storage_(capacity_),
                                                    initpos_{0},
                                                    size_{0}
{
    if (s == 0) ELE_CODE_INVARG("Invalid capacity for circular buffer");
}   
 
template <typename ElemType>
ElemType & CircularBuffer<ElemType>::back(void)
{
    if (empty()) ELE_CODE_INVSTATE("Empty circular buffer has no back");
    return(storage_[index(size_ - 1)]);
}
 
template <typename ElemType>
void CircularBuffer<ElemType>::push_back(const ElemType & e)
{
    if (size_ == capacity_) pop_front();
    storage_[index(size_)] = e;
    ++size_;
}
 
template <typename ElemType>
ElemType & CircularBuffer<ElemType>::front(void)
{
    if (empty()) ELE_CODE_INVSTATE("Empty circular buffer has no front");
    return(storage_[initpos_]);
}
 
template <typename ElemType>
void CircularBuffer<ElemType>::pop_front(void)
{
    if (empty()) ELE_CODE_INVSTATE("Cannot pop from empty circular buffer");
    ++initpos_;
    if (initpos_ >= capacity_) initpos_ = 0;
    --size_;
}
 
template <typename ElemType>
ElemType & CircularBuffer<ElemType>::operator[](size_t ind)
{
    if (ind >= size_) ELE_CODE_OUTOFRANGE("Not such index in the buffer");
    return(storage_[index(ind)]);
}
 
 // circulabuffer
 
 
} // end adts namespace
 
} // end elementa namespace
 
 
#endif