/*

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

*/

#include <QtDebug>

#include "asciireader.h"

/// If set to this value number of channels is determined from input

#define NUMOFCHANNELS_AUTO   (0)

{

    paused = false;

    discardFirstLine = true;

    delimiter = _settingsWidget.delimiter();

    connect(&_settingsWidget, &AsciiReaderSettings::numOfChannelsChanged,

            [this](unsigned value)

            {

                if (!autoNumOfChannels)

                {

                    emit numOfChannelsChanged(value);

                }

            });

    connect(&_settingsWidget, &AsciiReaderSettings::delimiterChanged,

            [this](QChar d)

            {

                delimiter = d;

            });

    connect(device, &QIODevice::aboutToClose, [this](){discardFirstLine=true;});

}

QWidget* AsciiReader::settingsWidget()

{

    return &_settingsWidget;

}

{

    // do not allow '0'

}

// TODO: this could be a part of AbstractReader

void AsciiReader::enable(bool enabled)

{

    if (enabled)

    {

        discardFirstLine = true;

        QObject::connect(_device, &QIODevice::readyRead,

                         this, &AsciiReader::onDataReady);

    }

    else

    {

        QObject::disconnect(_device, 0, this, 0);

    }

}

void AsciiReader::pause(bool enabled)

{

    paused = enabled;

}

void AsciiReader::onDataReady()

{

    while(_device->canReadLine())

    {

        {

            continue;

        }

        auto separatedValues = line.split(delimiter, QString::SkipEmptyParts);

        unsigned numReadChannels; // effective number of channels to read

        unsigned numComingChannels = separatedValues.length();

        if (autoNumOfChannels)

        {

            // did number of channels changed?

            {

                emit numOfChannelsChanged(numComingChannels);

            }

            numReadChannels = numComingChannels;

        }

        {

        }

        else // there is missing channel data

        {

            numReadChannels = separatedValues.length();

            qWarning() << "Incoming data is missing data for some channels!";

            qWarning() << "Read line: " << line;

        }

        // parse read line

        unsigned numDataBroken = 0;

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

        {

            bool ok;

            if (!ok)

            {

                qWarning() << "Data parsing error for channel: " << ci;

                qWarning() << "Read line: " << line;

                numDataBroken++;

            }

        }

        if (numReadChannels > numDataBroken)

        {

            // commit data

        }

    }

}

void AsciiReader::saveSettings(QSettings* settings)

{

    _settingsWidget.saveSettings(settings);

}

void AsciiReader::loadSettings(QSettings* settings)

{

    _settingsWidget.loadSettings(settings);

}

/*

  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.

#define ASCIIREADER_H

#include <QSettings>

#include "abstractreader.h"

#include "asciireadersettings.h"

class AsciiReader : public AbstractReader

{

    Q_OBJECT

public:

    QWidget* settingsWidget();

    void enable(bool enabled = true);

    /// Stores settings into a `QSettings`

    void saveSettings(QSettings* settings);

    /// Loads settings from a `QSettings`.

    void loadSettings(QSettings* settings);

public slots:

    void pause(bool);

private:

    AsciiReaderSettings _settingsWidget;

    /// number of channels will be determined from incoming data

    unsigned autoNumOfChannels;

    QChar delimiter; ///< selected column delimiter

    bool paused;

    // We may have (usually true) started reading in the middle of a

    // line, so its a better idea to just discard first line.

    bool discardFirstLine;

private slots:

    void onDataReady();

};

  ../src/linindexbuffer.cpp

  ../src/ringbuffer.cpp

  ../src/readonlybuffer.cpp

  ../src/stream.cpp

  ../src/streamchannel.cpp

  ../src/channelinfomodel.cpp

  )

add_test(NAME test1 COMMAND Test)

qt5_use_modules(Test Widgets)

qt5_wrap_ui(UI_FILES_T

  ../src/binarystreamreadersettings.ui

  ../src/numberformatbox.ui

  ../src/endiannessbox.ui

  )

# test for readers

add_executable(TestReaders EXCLUDE_FROM_ALL

  test_readers.cpp

  ../src/samplepack.cpp

  ../src/sink.cpp

  ../src/source.cpp

  ../src/binarystreamreader.cpp

  ../src/binarystreamreadersettings.cpp

  ../src/endiannessbox.cpp

  ../src/numberformatbox.cpp

  ../src/numberformat.cpp

  ${UI_FILES_T}

  )

qt5_use_modules(TestReaders Widgets Test)

add_test(NAME test_readers COMMAND TestReaders)

set(CMAKE_CTEST_COMMAND ctest -V)

add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND})

add_dependencies(check Test TestReaders)

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

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

*/

// This tells Catch to provide a main() - only do this in one cpp file per executable

#define CATCH_CONFIG_RUNNER

#include "catch.hpp"

#include <QSignalSpy>

#include <QBuffer>

#include "binarystreamreader.h"

#include "test_helpers.h"

static const int READYREAD_TIMEOUT = 10; // milliseconds

TEST_CASE("reading data with BinaryStreamReader", "[reader]")

{

    QBuffer bufferDev;

    BinaryStreamReader bs(&bufferDev);

    bs.enable(true);

    TestSink sink;

    bs.connectSink(&sink);

    REQUIRE(sink._numChannels == 1);

    REQUIRE(sink._hasX == false);

    bufferDev.open(QIODevice::ReadWrite);

    const char data[] = {0x01, 0x02, 0x03, 0x04};

    bufferDev.write(data, 4);

    bufferDev.seek(0);

    QSignalSpy spy(&bufferDev, SIGNAL(readyRead()));

    // readyRead isn't signaled because there are no connections to it

    REQUIRE_FALSE(spy.wait(READYREAD_TIMEOUT));

    REQUIRE(sink.totalFed == 0);

}

// Note: this is added because `QApplication` must be created for widgets

#include <QApplication>

int main(int argc, char* argv[])

{

    QApplication a(argc, argv);

    int result = Catch::Session().run( argc, argv );

    return result;

}