{

        xData = new RingBuffer(ns);

    }

    else

    {

        xData = new IndexBuffer(ns);

    }

    // create channels

    for (unsigned i = 0; i < nc; i++)

    {

        auto c = new StreamChannel(i, xData, new RingBuffer(ns), &_infoModel);

        channels.append(c);

    }

}

Stream::~Stream()

{

    // notify deletion

    // delete channels

}

bool Stream::hasX() const

{

    return _hasx;

}

unsigned Stream::numChannels() const

{

    return channels.length();

}

unsigned Stream::numSamples() const

{

    return _numSamples;

}

const StreamChannel* Stream::channel(unsigned index) const

{

    Q_ASSERT(index < numChannels());

    return channels[index];

}

StreamChannel* Stream::channel(unsigned index)

{

    return const_cast<StreamChannel*>(static_cast<const Stream&>(*this).channel(index));

}

void Stream::setNumChannels(unsigned nc, bool x)

{

    unsigned oldNum = numChannels();

    if (oldNum == nc && x == _hasx) return;

    // adjust the number of channels

    if (nc > oldNum)

    {

        for (unsigned i = oldNum; i < nc; i++)

        {

            auto c = new StreamChannel(i, xData, new RingBuffer(_numSamples), &_infoModel);

            channels.append(c);

        }

    }

    else if (nc < oldNum)

    {

        for (unsigned i = oldNum-1; i > nc-1; i--)

        {

            delete channels.takeLast();

        }

    }

    // change the xdata

    if (x != _hasx)

    {

        if (x)

        {

            xData = new RingBuffer(_numSamples);

        }

        else

        {

            xData = new IndexBuffer(_numSamples);

        }

        for (auto c : channels)

        {

            c->setX(xData);

        }

        _hasx = x;

    }

    if (nc != oldNum)

    {

        _infoModel.setNumOfChannels(nc);

        // TODO: how abut X change?

        emit numChannelsChanged(nc);

    }

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License

  along with serialplot.  If not, see <http://www.gnu.org/licenses/>.

*/

#ifndef STREAM_H

#define STREAM_H

#include <QObject>

#include <QModelIndex>

#include <QVector>

#include <QSettings>

#include "sink.h"

#include "source.h"

#include "channelinfomodel.h"

#include "streamchannel.h"

#include "framebuffer2.h"

/**

 * Main waveform storage class. It consists of channels. Channels are

 * synchronized with each other.

 *

 * Implements `Sink` class for data entry. It's expected to be

 * connected to a `Device` source.

 */

class Stream : public QObject, public Sink

{

    Q_OBJECT

public:

    /**

     * @param nc number of channels

     * @param x has X data input

     * @param ns number of samples

     */

    Stream(unsigned nc = 0, bool x = false, unsigned ns = 0);

    ~Stream();

    // implementations for `Source`

    virtual bool hasX() const;

    virtual unsigned numChannels() const;

    unsigned numSamples() const;

    const StreamChannel* channel(unsigned index) const;

    StreamChannel* channel(unsigned index);

    /// Saves channel information

    void saveSettings(QSettings* settings) const;

    /// Load channel information

    void loadSettings(QSettings* settings);

protected:

    // implementations for `Sink`

    virtual void setNumChannels(unsigned nc, bool x);

    virtual void feedIn(const SamplePack& data);

signals:

    void numChannelsChanged(unsigned value);

    void numSamplesChanged(unsigned value);

    void channelAdded(const StreamChannel* chan);

    void channelNameChanged(unsigned channel, QString name); // TODO: does it stay?

    void dataAdded(); ///< emitted when data added to channel man.

public slots:

    // TODO: these won't be public

    // void setNumChannels(unsigned number);

    void setNumSamples(unsigned value);

    /// When paused data feed is ignored

    void pause(bool paused);

private:

    unsigned _numSamples;

    bool _paused;

    bool _hasx;

    ResizableBuffer* xData;

    QList<StreamChannel*> channels;

    ChannelInfoModel _infoModel;

};

#endif // STREAM_H