test_sdk/script/gtl_scr_engine.h

#ifndef GTL_SCR_ENGINE_H
#define GTL_SCR_ENGINE_H

#include <QObject>
#include <QQmlEngine>
#include <QJSValue>
#include <QJsonObject>
#include <QJsonArray>

#include "script_global.h"

#include "core/gtl_analog_data.h"
#include "math/gtl_math_analog_value.h"

#include "hw/gtl_hw_player_file.h"

#include "script/gtl_scr_spec.h"
#include "script/gtl_scr_analog_data.h"

namespace gtl
{
    namespace scr
    {
        class player : public QThread
        {
            Q_OBJECT
        public:
            player(gtl::hw::player_file* file, const std::vector<int> &channesl, QObject* parent = NULL);
            ~player();
            void start();
            void stop();
            qreal rate() const;
            void confirm();
            int samples() const;
            qreal* data() const;
            const std::vector<int>& channels() const;

        private:
            gtl::hw::player_file* _file;
            int _samples;
            std::vector<qreal> _buffer;
            bool _is_playing;
            bool _status;
            std::vector<int> _channels;

        private:
            void run() override;

        signals:
            void data_read();
        };



        class log : public QObject
        {
            Q_OBJECT
        public:
            log(QObject* parent = NULL);

        public slots:
            void info(QString tag, QString message);
            void warning(QString tag, QString message);
            void error(QString tag, QString message);
            void debug(QString tag, QString message);

        signals:
            void new_message(QString, QString);

        };

        class SCRIPT_EXPORT engine : public QObject
        {
            Q_OBJECT
            Q_PROPERTY(QVariant analog_inputs READ get_analog_inputs NOTIFY analog_inputs_changed)
            Q_PROPERTY(log* log READ get_log CONSTANT)
            Q_PROPERTY(QJsonObject options READ get_options NOTIFY options_changed)
            Q_PROPERTY(QJsonObject results READ get_results WRITE set_results NOTIFY results_changed)

        public:
            engine(QObject* parent = NULL);
            ~engine();

            virtual bool evaluate(QString program);

            void clear_options();
            void set_options(const QJsonObject &root);
            void get_results(QJsonObject &root);

            virtual void clear();

            void get_state(QJsonObject &root) const;

            bool set_file(QString path = "", std::vector<int> = std::vector<int>());

            QQmlEngine *qml_engine() const;

            void set_ad(std::vector<gtl::analog_data*>::iterator begin, std::vector<gtl::analog_data*>::iterator end);

            void add_local_import_path(QString path);
            void clear_local_import_paths();

            analog_data* analog_input(int idx);

        public:
            static QStringList import_paths;

        protected:
            QQmlEngine* _engine;
            QObjectList _analog_inputs;
            QJsonObject _options;
            QJsonObject _results;

            player* _player;


        private:
            QObjectList _objects;
            log *_log;
            gtl::hw::player_file* _file;
            QStringList _local_import_paths;


        private:
            QVariant get_analog_inputs() const;
            bool is_type(QObject* obj, QString type) const;
            bool is_gtl_analog_data(QObject* obj);
            bool is_gtl_math_analog_value(QObject* obj) const;
            bool is_gtl_scr_spec(QObject* obj) const;
            log* get_log() const;
            QJsonObject get_options() const;
            QJsonObject get_results() const;

            virtual void clear_objects();

        protected:
            virtual void init();


        public slots:
            void add_ad(gtl::analog_data* ad);
            void remove_ad(gtl::analog_data* ad);
            void remove_all_ad();

            QJSValue add_value_sum(QJSValue parent);
            QJSValue add_value_rms(QJSValue parent);
            QJSValue add_value_var(QJSValue parent);
            QJSValue add_value_freq(QJSValue parent);
            QJSValue add_value_ampl(QJSValue parent);
            QJSValue add_value_kurt(QJSValue parent);
            QJSValue add_delta_phase(QJSValue parent, QJSValue parent1);
            QJSValue add_delta_phase_spec(QJSValue parent, QJSValue parent1);

            QJSValue add_filter_iir(QJSValue parent);
            QJSValue add_intg(QJSValue parent);
            QJSValue add_diff(QJSValue parent);

            QJSValue add_ausp(QJSValue parent);
            QJSValue add_spen(QJSValue parent);

            QJSValue get_analog_input(QString name);

            QJSValue import(QString file_name);

            qreal get_kurt_value(const QJsonArray &data_array) const;
            qreal get_var_value(const QJsonArray &data_array) const;

        protected slots:
            virtual void device_recieved_data();

        private slots:
            void deleting_ad();
            void deleting_object();
            void create_jsobject(QObject* obj, QJSValue &js_object);
            void set_results(const QJsonObject &value);
            void set_data_from_file();

        signals:
            void analog_inputs_changed();
            void spec_created(spec*);
            void base_index_created(gtl::math::analog_value*);

            void options_changed();
            void results_changed();

            void log_message(QString, QString);
        };
    }
}

#endif // GTL_SCR_ENGINE_H