hmemorywriter.h

#ifndef __HMEMORYWRITER_H
#define __HMEMORYWRITER_H
 
template <class T>
class HMemoryWriter : public HWriter<T>, public HWriterConsumer<T>
{
    private:
 
        T* _buffer;
        int _size;
        int _pos;
        bool _infinite;
 
    public:
 
        HMemoryWriter(T* buffer, size_t size, bool infinite = false):
            _buffer(buffer),
            _size(size),
            _pos(0),
            _infinite(infinite)
        {}
 
        HMemoryWriter(HWriterConsumer<T>* consumer, T* buffer, size_t size, bool infinite = false):
            _buffer(buffer),
            _size(size),
            _pos(0),
            _infinite(infinite)
        {
            consumer->SetWriter(this);
        }
 
        int Write(T* src, size_t blocksize)
        {
            if( _pos + blocksize > _size ) {
                return 0;
            }
            memcpy((void*) &_buffer[_pos], (void*) src, blocksize * sizeof(T));
            _pos += _infinite ? 0 : blocksize;
            return blocksize;
        }
 
        void SetWriter(HWriter<T>* writer)
        {
            // Not used, writes into a buffer
        }
 
        bool Command(HCommand* command) {
            // No further propagation of commands
            return true;
        }
 
        void Reset() {
            _pos = 0;
        }
 
        int GetPosition() {
            return _pos;
        }
 
        int GetSize() {
            return _size;
        }
};
 
#endif