hmux.h

#ifndef __HMUX_H
#define __HMUX_H
 
#include "hreader.h"
#include "hwriter.h"
#include "hwriterconsumer.h"
#include "hprobe.h"
 
template <class T>
class HMux : public HReader<T>, public HWriter<T>, public HWriterConsumer<T>
{
    private:
 
        int _blocksize;
 
        std::vector< HReader<T>* > _readers;
 
        int _writers;
        HWriter<T>* _writer;
        int _received;
        T* _output;
 
        T** _buffers;
        int _bufferCount;
 
        bool _duplex;
 
    public:
 
        HMux( std::vector< HReader<T>* > readers, size_t blocksize, bool duplex = false);
 
        HMux( HWriter<T>* writer, int writers, size_t blocksize, bool duplex = false);
 
        HMux( std::vector< HWriterConsumer<T>* > consumers, size_t blocksize, bool duplex = false);
 
        ~HMux();
 
        int Read(T* dest, size_t blocksize);
 
        int Write(T* src, size_t blocksize);
 
        bool Command(HCommand* command) {
            if( _readers.size() != 0 ) {
                for (int i = 0; i < _readers.size(); i++) {
                    if (!_readers[i]->Command(command)) {
                        return false;
                    }
                }
                return true;
            }
            else if( _writer != nullptr ) {
                return _writer->Command(command);
            }
            return true;
        }
 
        void SetWriter(HWriter<T>* writer)
        {
            _writer = writer;
        }
 
        bool Start()
        {
            if( _writer != nullptr ) {
                return _writer->Start();
            }
            if( _readers.size() > 0 ) {
                for (int i = 0; i < _readers.size(); i++) {
                    if (!_readers[i]->Start()) {
                        return false;
                    }
                }
            }
            return true;
        }
 
        bool Stop()
        {
            if( _writer != nullptr ) {
                return _writer->Stop();
            }
            if( _readers.size() > 0 ) {
                for (int i = 0; i < _readers.size(); i++) {
                    if (!_readers[i]->Stop()) {
                        return false;
                    }
                }
            }
            return true;
        }
};
 
#endif