detectorcache.h

#ifndef _DETECTORCACHE_H_
#define _DETECTORCACHE_H_

#include "slidingbuffer.h"
#include "detectorbank.h"

namespace detectorcache {
    
    class Producer : public slidingbuffer::SegmentProducer<result_t *>
    {
    public:
        Producer(DetectorBank &db,
                 std::istream* is = nullptr)
            : db{db}
            , audiostream{is} {};
        virtual std::size_t generate(result_t* seg[],
                                     const std::size_t idx,
                                     const std::size_t size);
        virtual bool more(void) { return db.tell() < db.getBuflen(); }; //const?
        void set_num_samps(std::size_t n) { seg_len = n; }; // private? Friend function of Detectorcache?
        void set_start_chan(std::size_t c) { start_chan = c; };
        
        // ACCESS FUNCTIONS - return values from the DetectorBank
        
        parameter_t getSR(void) const { return db.getSR(); };
        std::size_t getChans(void) { return db.getChans(); }; //const?
        std::size_t getBuflen(void) { return db.getBuflen(); }; //const?
        parameter_t getW(std::size_t ch) {return db.getW(ch);};
        parameter_t getFreqIn(std::size_t ch) {return db.getFreqIn(ch);};        
        
    protected:
        DetectorBank& db;             
        std::size_t seg_len;           
        std::istream* audiostream;     
        std::size_t start_chan;        
    };
    
    class Segment : public slidingbuffer::Segment<result_t *, detectorcache::Producer>
    {
    public:
        Segment(const std::size_t size, const std::size_t origin,
                Producer& sp);
        virtual ~Segment();
    
        friend class Producer;
    };
    
    class DetectorCache
        : public slidingbuffer::SlidingBuffer<result_t *,
                                              detectorcache::Segment,
                                              detectorcache::Producer>
    { 
    public:
        DetectorCache(Producer& p,
                      const std::size_t num_segs,
                      const std::size_t seg_len,
                      const std::size_t start_chan,
                      const std::size_t num_chans);
        
        DetectorCache(detectorcache::Producer& p,
                      const std::size_t num_segs,
                      const std::size_t seg_len,
                      const std::size_t start_chan = 0)
            : DetectorCache(p,
                            num_segs,
                            seg_len,
                            start_chan,
                            p.getChans()) { }

        result_t getResultItem(long int ch, long int n);
        std::size_t getPreviousResults(const std::size_t chan,
                                       const std::size_t currentSample,
                                       result_t* samples, std::size_t numSamples);
        std::size_t end(void) { return p.getBuflen(); };
        parameter_t getSR(void) const { return p.getSR(); };
        std::size_t getChans(void) { return chans; };
        
    protected:
        const std::size_t chans;       
        const std::size_t seg_len;     
        Producer& p;                   
        const std::size_t start_chan;  
    };

};

#endif