hswitch.h

#ifndef __HSWITCH_H
#define __HSWITCH_H
 
#include "hreader.h"
#include "hwriter.h"
 
#include <vector>
 
template <class T>
class HSwitch: public HReader<T>, public HWriter<T>, public HWriterConsumer<T>
{
    public:
 
        struct ComponentPtr
        {
            HReader<T>* Reader;
 
            HWriter<T>* Writer;
 
            ComponentPtr(HReader<T>* reader)
            {
                Reader = reader;
                Writer = nullptr;
            }
 
            ComponentPtr(HWriter<T>* writer)
            {
                Reader = nullptr;
                Writer = writer;
            }
        };
 
    private:
 
        HWriter<T>* _writer;
        HReader<T>* _reader;
        size_t _blocksize;
 
        T* _buffer;
 
        bool _isWriter;
        bool _isWriterConsumer;
        bool _isReader;
 
        int _position;
 
        std::vector<ComponentPtr> _components;
 
    public:
 
        HSwitch(HWriter<T>* writer, size_t blocksize);
 
        HSwitch(HWriterConsumer<T>* consumer, size_t blocksize);
 
        HSwitch(HReader<T>* reader, size_t blocksize);
 
        void SetWriter(HWriter<T>* writer);
 
    public:
 
        ~HSwitch();
 
        int Write(T* src, size_t blocksize);
 
        int Read(T* dest, size_t blocksize);
 
        void SetPosition(int position);
 
        int GetPosition();
 
        void Add(HReader<T>* reader);
 
        void Add(HWriter<T>* writer);
 
        bool Start();
 
        bool Stop();
 
        bool Command(HCommand* command) {
            if( _writer != nullptr && _position == 0 )
            {
                if( !_writer->Command(command) )
                {
                    return false;
                }
            }
            if( _reader != nullptr && _position == 0 )
            {
                if( !_reader->Command(command) )
                {
                    return false;
                }
            }
            if( _position > 0 )
            {
                if( _components.at(_position - 1).Reader != nullptr )
                {
                    if( !_components.at(_position - 1).Reader->Command(command) )
                    {
                        return false;
                    }
                }
                if( _components.at(_position - 1).Writer != nullptr )
                {
                    if( !_components.at(_position - 1).Writer->Command(command) )
                    {
                        return false;
                    }
                }
            }
            return true;
        }
};
 
#endif