slidingbuffer.h

#ifndef _SLIDINGBUFFER_H_
#define _SLIDINGBUFFER_H_

#include <cstddef>
#include <stdexcept>
#include <deque>
#include <memory>

#include "uniqueallocator.h"

#include <iostream>

namespace slidingbuffer {

    class SlidingBufferException
        : public std::runtime_error {
    public:
        SlidingBufferException(const char* what, const long int idx)
            : std::runtime_error(what)
            , index { idx }
            { };
        const long int index;   
    };
    
    class NegativeIndexException
        : public SlidingBufferException {
    public:
        NegativeIndexException(const long int idx)
            : SlidingBufferException(
                "SlidingBuffer: Attempt to access negative index",
                idx) { };
    };
    
    class ExpiredIndexException
        : public SlidingBufferException {
    public:
        ExpiredIndexException(const long int idx)
            : SlidingBufferException(
                "SlidingBuffer: Indexed item no longer available (underflow)",
                idx) { };
    };
    
    class IndexOutOfRangeException
        : public SlidingBufferException {
    public:
        IndexOutOfRangeException(const long int idx)
            : SlidingBufferException(
                "SlidingBuffer: Attempt to access past end of data",
                idx) { };
    };
    
    template <typename T> class SegmentProducer {
    public:
        virtual ~SegmentProducer() { };
        virtual std::size_t generate(T seg[],
                                     const std::size_t idx,
                                     const std::size_t size) = 0;
        
        virtual bool more(void) = 0;
    };
    
    template <typename T, typename P> class Segment {
    protected:
        T* seg;                   
        bool valid;               
        std::size_t size;         
        const std::size_t origin; 
        P& sp;                    
    public:
        Segment(const std::size_t size, const std::size_t origin, P& sp) 
            : seg { new T [size] }
            , valid { false }
            , size { sp.generate(seg, origin, size) } // size is number of elements (channels)
            , origin { origin }
            , sp { sp }
        { }
        
        virtual ~Segment() {
            delete[] seg;
        }
        
        T& operator[](std::size_t idx) {
            /*TODO Check the Segment Producer has more data */
            if (!valid) {
//std::cout << "\nSegment origin " << origin << " not yet valid... calling producer\n";
                valid = true;
            }
//std::cout << "\nSeg idx: " << idx << std::endl;
            return seg[idx];
        }
        
        std::size_t get_size(void) const { return size; }
    };
    
    template <typename T, typename S, typename P> class SlidingBuffer {
    protected:
        std::size_t origin;          
        const std::size_t max_segs;
        const std::size_t seg_size;   
        std::deque<S*, UniqueAllocator<S*>> segs;
        P& sp;                        
    public:
        SlidingBuffer(P& sp,
                      const std::size_t max_segs,
                      const std::size_t seg_size
                      )
            : origin { 0 }
            , max_segs { max_segs }
            , seg_size { seg_size }
            , sp { sp }
        {
//              for (std::size_t i { 0 }; i < max_segs; i++)
//                  segs[i] = nullptr;
//                 segs[i] = new S(seg_size, seg_size*i, sp);
        };
        
        virtual ~SlidingBuffer() { };
        
        T& operator[](long int idx)  {

            if (idx < 0)
                throw NegativeIndexException(idx);
            
            if (static_cast<size_t>(idx) < origin) // Avoid casting origin to int
                throw ExpiredIndexException(idx);
            
            std::size_t segment { (static_cast<std::size_t>(idx) - origin) / seg_size };

            while (segment >= segs.size()) {
                
//std::cout << "segment: " << segment << ", origin: " << origin << ", segs.size: " << segs.size() << std::endl;
                    
                segs.push_back(new S(seg_size,
                                     origin + segs.size() * seg_size,
                                     sp)
                              );
                
                if (segs.size() > max_segs) {
                    //delete segs.front();
                    segs.pop_front();
                    origin += seg_size;
                    --segment;
                }

            }

            S* const s { segs[segment] };
            std::size_t const i { idx%seg_size };

            if (s->get_size() <= i)
                throw IndexOutOfRangeException(idx);
//std::cout << "Access " << segment << "[" << i << "]\n";
            return (*s)[i];
        }
    };

} // namespace slidingbuffer

#endif // _SLIDINGBUFFER_H_