hfilewriter.h

#ifndef __HFILEWRITER_H
#define __HFILEWRITER_H
 
#include <stdio.h>
#include <fstream>
 
#include "hwriter.h"
#include "hwriterconsumer.h"
 
template <class T>
class HFileWriter : public HWriter<T>
{
    private:
 
        std::ofstream _stream;
        const std::string _filename;
        bool _seq;
        int _seqCount;
 
    public:
 
        HFileWriter(const char* filename, bool sequence = false):
                _filename(std::string(filename)),
                _seq(sequence)
        {}
 
        HFileWriter(const std::string filename, bool sequence = false):
                _filename(filename),
                _seq(sequence)
        {}
 
        HFileWriter(const char* filename, HWriterConsumer<T>* consumer, bool sequence = false):
                _filename(std::string(filename)),
                _seq(sequence)
        {
            consumer->SetWriter(this);
        }
 
        HFileWriter(const std::string filename, HWriterConsumer<T>* consumer, bool sequence = false):
                _filename(filename),
                _seq(sequence)
        {
            consumer->SetWriter(this);
        }
 
        virtual int Write(T* src, size_t blocksize)
        {
            _stream.write((char*) src, blocksize * sizeof(T));
            return blocksize;
        }
 
        bool Start()
        {
            HLog("Trying to open stream for %s", _filename.c_str());
            std::string fname;
            if( _seq ) {
                fname = std::to_string(_seqCount++) + "-" + _filename;
            } else {
                fname = _filename;
            }
            _stream.open(fname.c_str(), std::ios::out | std::ios::binary | std::ios::trunc);
            if( !_stream.is_open())
            {
                HError("Failed to open file %s", _filename.c_str());
                return false;
            }
            HLog("Stream is open");
            return true;
        }
 
        bool Stop()
        {
            HLog("Closing stream");
            _stream.close();
            return true;
        }
 
        void Seek(int bytes)
        {
            _stream.seekp(bytes, std::ios::beg);
        }
 
        bool Command(HCommand* command) {
            // No ruther propagation of commands
            return true;
        }
};
 
#endif