hdemux.h

#ifndef __HDEMUX_H
#define __HDEMUX_H
 
template <class T>
class HDeMux : public HWriter<T>, public HWriterConsumer<T>, public HReader<T>
{
    private:
 
        std::vector< HWriter<T>* > _writers;
        HReader<T>* _reader;
        T** _buffers;
        size_t _blocksize;
 
        int _readers;
        T* _readBuffer;
        int _nextReader;
 
    public:
 
        HDeMux( std::vector< HWriter<T>* > writers, size_t blocksize);
 
        HDeMux( HWriterConsumer<T>* consumer, size_t blocksize);
 
        HDeMux( HReader<T>* reader, int readers, size_t blocksize);
 
        ~HDeMux();
 
        int Write(T* src, size_t blocksize);
 
        int Read(T* dest, size_t blocksize);
 
        void SetWriter(HWriter<T>* writer)
        {
            if( _buffers != NULL )
            {
                for( int i = 0; i < _writers.size(); i++ )
                {
                    delete _buffers[i];
                }
                delete _buffers;
            }
 
            _writers.push_back(writer);
 
            _buffers = new T*[_writers.size()];
            for( int i = 0; i < _writers.size(); i++ )
            {
                _buffers[i] = new T[_blocksize / _writers.size()];
            }
        }
 
        bool Command(HCommand* command) {
            typename std::vector< HWriter<T>* >::iterator it;
 
            for( it = _writers.begin(); it != _writers.end(); it++ ) {
                if( !(*it)->Command(command) ) {
                    return false;
                }
            }
            return true;
        }
 
        bool Start() {
            typename std::vector< HWriter<T>* >::iterator it;
 
            for( it = _writers.begin(); it != _writers.end(); it++ ) {
                if( !(*it)->Start() ) {
                    return false;
                }
            }
            return true;
        }
 
        bool Stop() {
            typename std::vector< HWriter<T>* >::iterator it;
 
            for( it = _writers.begin(); it != _writers.end(); it++ ) {
                if( !(*it)->Stop() ) {
                    return false;
                }
            }
            return true;
        }
};
 
#endif