hfilter.h

#ifndef __HFILTER_H
#define __HFILTER_H
 
#include "hprobe.h"
 
template <class T>
class HFilter : public HFilterBase<T>, public HWriter<T>, public HReader<T>, public HWriterConsumer<T>
{
    private:
 
        HWriter<T>* _writer;
        HReader<T>* _reader;
 
        HProbe<T>* _probe;
 
        T* _buffer;
 
        bool _enabled;
 
        void Init() {
 
            _buffer = new T[_blocksize];
            HLog("Allocated %d as local buffer", _blocksize * sizeof(T));
        }
 
    protected:
 
        int _blocksize;
 
        HFilter(HWriter<T>* writer, size_t blocksize, HProbe<T>* probe = NULL):
            _writer(writer),
            _reader(NULL),
            _blocksize(blocksize),
            _probe(probe),
            _enabled(true) {
 
            HLog("HFilter(HWriter*)");
            Init();
        }
 
        HFilter(HWriterConsumer<T>* consumer, size_t blocksize, HProbe<T>* probe = NULL):
            _reader(NULL),
            _blocksize(blocksize),
            _probe(probe),
            _enabled(true) {
 
            HLog("HFilter(HWriter*)");
            Init();
 
            consumer->SetWriter(this);
        }
 
        HFilter(HReader<T>* reader, size_t blocksize, HProbe<T>* probe = NULL):
            _writer(NULL),
            _reader(reader),
            _blocksize(blocksize),
            _probe(probe),
            _enabled(true) {
 
            HLog("HFilter(HReader*)");
            Init();
        }
 
        void SetWriter(HWriter<T>* writer)
        {
            _writer = writer;
        }
 
    public:
 
        ~HFilter() {
            HLog("~HFilter()");
            delete _buffer;
        }
 
        int Write(T* src, size_t blocksize) {
 
            if( blocksize > _blocksize )
            {
                HError("Illegal blocksize in Write() to HFilter. Initialized with %d called with %d", _blocksize, blocksize);
                throw new HFilterIOException("It is not allowed to write more data than the size given at creation of the filter");
            }
 
            if( _enabled ) {
                Filter(src, _buffer, blocksize);
            } else {
                memcpy((void*) _buffer, (void*) src, sizeof(T) * blocksize);
            }
            int written = _writer->Write(_buffer, blocksize);
 
            if( _probe != NULL )
            {
                _probe->Write(_buffer, blocksize);
            }
 
            return written;
        }
 
        int Read(T* dest, size_t blocksize) {
 
            if( blocksize > _blocksize )
            {
                HError("Illegal blocksize in Read() to HFilter. Initialized with %d called with %d", _blocksize, blocksize);
                throw new HFilterIOException("It is not possible to read more data than the size given at creation of the filter");
            }
 
            int received = _reader->Read(_buffer, blocksize);
            if( _enabled ) {
                Filter(_buffer, dest, received);
            } else {
                memcpy((void*) dest, (void*) _buffer, sizeof(T) * blocksize);
            }
 
            if( _probe != NULL )
            {
                _probe->Write(_buffer, blocksize);
            }
 
            return received;
        }
 
        virtual void Filter(T* src, T* dest, size_t blocksize) = 0;
 
        bool Start() {
 
            if( _reader != NULL )
            {
                HLog("Calling Start() on reader");
                return _reader->Start();
            }
            if( _writer != NULL )
            {
                HLog("Calling Start() on writer");
                return _writer->Start();
            }
            return false;
        }
 
        bool Stop() {
 
            if( _reader != NULL )
            {
                HLog("Calling Stop() on reader");
                return _reader->Stop();
            }
            if( _writer != NULL )
            {
                HLog("Calling Stop() on writer");
                return _writer->Stop();
            }
            return false;
        }
 
        bool Command(HCommand* command) {
            if( _writer != nullptr ) {
                return _writer->Command(command);
            } else if( _reader != nullptr ) {
                return _reader->Command(command);
            }
            return true;
        }
 
        void Enable() {
            _enabled = true;
        }
 
        void Disable() {
            _enabled = false;
        }
 
        bool GetEnabled() {
            return _enabled;
        }
 
    public:
 
        static std::vector<float> ReadCoeffsFromFile(std::string filename)
        {
            char name[filename.length() + 1];
            strcpy(name, filename.c_str());
 
            return ReadCoeffsFromFile(name);
        }
 
        static std::vector<float> ReadCoeffsFromFile(char* filename)
        {
            std::vector<float> coeffs;
 
            #define BEGIN 0
            #define DIGIT 1
            #define SEPARATOR 2
            #define JUNK 3
            #define COMMENT_BEGIN 4
            #define COMMENT 5
 
            std::ifstream coeffsFile(filename);
            if (coeffsFile.is_open())
            {
                try
                {
                    std::string block;
 
                    while( !coeffsFile.eof() )
                    {
                        std::getline(coeffsFile, block);
 
                        int state = BEGIN;
                        std::string washed = "";
                        for( int i = 0; i < block.length(); i++ )
                        {
                            switch(state)
                            {
                                case BEGIN:
                                    switch(block[i])
                                    {
                                        case '0':
                                        case '1':
                                        case '2':
                                        case '3':
                                        case '4':
                                        case '5':
                                        case '6':
                                        case '7':
                                        case '8':
                                        case '9':
                                        case '-':
                                        case '+':
                                            state = DIGIT;
                                            washed += block[i];
                                            break;
                                        case ' ':
                                        case ',':
                                        case ';':
                                            state = SEPARATOR;
                                            break;
                                        case '/':
                                            state = COMMENT_BEGIN;
                                            break;
                                        default:
                                            state = JUNK;
                                            break;
                                    }
                                    break;
 
                                case DIGIT:
                                    switch(block[i]) {
                                        case '0':
                                        case '1':
                                        case '2':
                                        case '3':
                                        case '4':
                                        case '5':
                                        case '6':
                                        case '7':
                                        case '8':
                                        case '9':
                                        case '.':
                                            state = DIGIT;
                                            washed += block[i];
                                            break;
                                        case ' ':
                                        case ',':
                                        case ';':
                                            if( washed.length() > 0 ) {
                                                coeffs.push_back(std::stof(washed));
                                                washed = "";
                                            }
                                            state = SEPARATOR;
                                            break;
                                        case '/':
                                            if( washed.length() > 0 ) {
                                                coeffs.push_back(std::stof(washed));
                                                washed = "";
                                            }
                                            state = COMMENT_BEGIN;
                                            break;
                                        default:
                                            if( washed.length() > 0 ) {
                                                coeffs.push_back(std::stof(washed));
                                                washed = "";
                                            }
                                            state = JUNK;
                                            break;
                                    }
                                    break;
 
                                case SEPARATOR:
                                    switch(block[i]) {
                                        case '0':
                                        case '1':
                                        case '2':
                                        case '3':
                                        case '4':
                                        case '5':
                                        case '6':
                                        case '7':
                                        case '8':
                                        case '9':
                                        case '-':
                                        case '+':
                                            state = DIGIT;
                                            washed += block[i];
                                            break;
                                        case ' ':
                                        case ',':
                                        case ';':
                                            state = SEPARATOR;
                                            break;
                                        default:
                                            state = JUNK;
                                            break;
                                    }
                                    break;
 
                                case JUNK:
                                    switch(block[i])
                                    {
                                        case ' ':
                                        case ',':
                                        case ';':
                                            state = SEPARATOR;
                                            break;
                                        default:
                                            state = JUNK;
                                            break;
                                    }
 
                                case COMMENT_BEGIN:
                                    switch(block[i]) {
                                        case '/':
                                            state = COMMENT;
                                            break;
                                        default:
                                            state = JUNK;
                                            break;
                                    }
                                    break;
 
                                case COMMENT:
                                    state = COMMENT;
                            }
                        }
 
                        // Add remaining digits, if we are still reading digits
                        if( state == DIGIT && washed.length() > 0 )
                        {
                            coeffs.push_back(std::stof(washed));
                        }
                    }
                }
                catch( std::exception* ex )
                {
                    HError("Caught exception while reading coefficients file: %s", ex->what());
                    throw new HFilterInitializationException("Exception while reading coefficients from file");
                }
                catch( ... )
                {
                    HError("Caught unknown exception while reading coefficients file");
                    throw new HFilterInitializationException("Exception while reading coefficients from file");
                }
            }
            else
            {
                HError("No such file %s", filename);
                throw new HFilterInitializationException("Coefficients file not found");
            }
            coeffsFile.close();
 
            return coeffs;
        }
 
};
 
#endif