{

    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));

}

const ChannelInfoModel* Stream::infoModel() const

{

    return &_infoModel;

}

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);

    }

    Sink::setNumChannels(nc, x);

}

void Stream::feedIn(const SamplePack& data)

{

    Q_ASSERT(data.numChannels() == numChannels() &&

             data.hasX() == hasX());

    if (_paused) return;

    unsigned ns = data.numSamples();

    if (_hasx)

    {

        static_cast<RingBuffer*>(xData)->addSamples(data.xData(), ns);

    }

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

    {

        static_cast<RingBuffer*>(channels[i]->yData())->addSamples(data.data(i), ns);

    }

    Sink::feedIn(data);

}

void Stream::pause(bool paused)

{

    _paused = paused;

}

void Stream::setNumSamples(unsigned value)

{

    if (value == _numSamples) return;

    _numSamples = value;

    xData->resize(value);

    for (auto c : channels)

    {

        static_cast<RingBuffer*>(c->yData())->resize(value);

    }

}

void Stream::saveSettings(QSettings* settings) const

{

    _infoModel.saveSettings(settings);

}

void Stream::loadSettings(QSettings* settings)

{

    _infoModel.loadSettings(settings);

}

/*

  Copyright © 2018 Hasan Yavuz Özderya

  This file is part of serialplot.

  serialplot is free software: you can redistribute it and/or modify

  it under the terms of the GNU General Public License as published by

  the Free Software Foundation, either version 3 of the License, or

  (at your option) any later version.

  serialplot is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  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);

    const ChannelInfoModel* infoModel() const;

    /// 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

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

    {

        const StreamChannel* c = s.channel(i);

        REQUIRE(c != NULL);

        REQUIRE(c->index() == i);

    }

}

TEST_CASE("adding data to a stream with no X", "[memory, stream, data, sink]")

{

    Stream s(3, false, 10);

    // prepare data

    SamplePack pack(5, 3, false);

    for (unsigned ci = 0; ci < 3; ci++)

    {

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

        {

            pack.data(ci)[i] = i;

        }

    }

    TestSource so(3, false);

    so.connect(&s);

    // test

    so._feed(pack);

    for (unsigned ci = 0; ci < 3; ci++)

    {

        const StreamChannel* c = s.channel(ci);

        const FrameBuffer* y = c->yData();

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

        {

            REQUIRE(y->sample(i) == 0);

        }

        for (unsigned i = 5; i < 10; i++)

        {

            REQUIRE(y->sample(i) == i-5);

        }

    }

}

TEST_CASE("adding data to a stream with X", "[memory, stream, data, sink]")

{

    Stream s(3, true, 10);

    // prepare data

    SamplePack pack(5, 3, true);

    for (unsigned ci = 0; ci < 3; ci++)

    {

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

        {

            pack.data(ci)[i] = i;

        }

    }

    // x data

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

    {

        pack.xData()[i] = i+10;

    }

    TestSource so(3, true);

    so.connect(&s);

    // test

    so._feed(pack);

    for (unsigned ci = 0; ci < 3; ci++)

    {

        const StreamChannel* c = s.channel(ci);

        const FrameBuffer* y = c->yData();

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

        {

            REQUIRE(y->sample(i) == 0);

        }

        for (unsigned i = 5; i < 10; i++)

        {

            REQUIRE(y->sample(i) == i-5);

        }

    }

    // check x

    const FrameBuffer* x = s.channel(0)->xData();

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

    {

        REQUIRE(x->sample(i) == 0);

    }

    for (unsigned i = 5; i < 10; i++)

    {

        REQUIRE(x->sample(i) == (i-5)+10);

    }

}

{

    Stream s(3, false, 10);

    // prepare data

    SamplePack pack(5, 3, false);

    for (unsigned ci = 0; ci < 3; ci++)

    {

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

        {

            pack.data(ci)[i] = i;

        }

    }

    TestSource so(3, false);

    so.connect(&s);

    // test

    s.pause(true);

    so._feed(pack);

    for (unsigned ci = 0; ci < 3; ci++)

    {

        const StreamChannel* c = s.channel(ci);

        const FrameBuffer* y = c->yData();

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

        {

            REQUIRE(y->sample(i) == 0);

        }

    }

}