Administrace komentářů

Píši GUI aplikaci, která má číst standardní vstup a chci aby načtená data průběžně zobrazovala. Používám Qt a C++. Jsou tam potřeba dvě vlákna -- jedno pro GUI a jedno pro čtení vstupu. Z toho vlákna pro čtení nemůžu pracovat s GUI komponentami a plnit do nich hodnoty, to je jasné.

Dočetl jsem se, že nejsnazší způsob, jak tahle dvě vlákna propojit jsou signály a sloty. To jsem udělal a funguje mi to. Akorát mi připadá, že bylo potřeba napsat moc kódu, který nic zajímavého nedělá, jen přeposílá události -- a to je potřeba udělat pro každou metodu. Výsledek:

#pragma once

#include <QObject>

#include <relpipe/reader/typedefs.h>
#include <relpipe/reader/TypeId.h>
#include <relpipe/reader/handlers/RelationalReaderStringHandler.h>
#include <relpipe/reader/handlers/AttributeMetadata.h>

using namespace relpipe::reader;
using namespace relpipe::reader::handlers;

// signal/slot parameters must be declared here and registered with qRegisterMetaType()

Q_DECLARE_METATYPE(string_t)
Q_DECLARE_METATYPE(std::vector<AttributeMetadata>)

class QtRelationalReaderStringHadler : public QObject, public RelationalReaderStringHadler {
	Q_OBJECT
private:
	RelationalReaderStringHadler* target;
public:

	QtRelationalReaderStringHadler(QObject* parent, RelationalReaderStringHadler* target) :
	QObject(parent), target(target) {

		// see Q_DECLARE_METATYPE above
		qRegisterMetaType<string_t>();
		qRegisterMetaType<std::vector < AttributeMetadata >> ();

		QObject::connect(this, &QtRelationalReaderStringHadler::signal_startRelation, this, &QtRelationalReaderStringHadler::slot_startRelation);
		QObject::connect(this, &QtRelationalReaderStringHadler::signal_attribute, this, &QtRelationalReaderStringHadler::slot_attribute);
		QObject::connect(this, &QtRelationalReaderStringHadler::signal_endOfPipe, this, &QtRelationalReaderStringHadler::slot_endOfPipe);
	}

	virtual ~QtRelationalReaderStringHadler() {

	}

	virtual void startRelation(string_t name, std::vector<AttributeMetadata> attributes) override {
		emit signal_startRelation(name, attributes);
	}

	virtual void attribute(const string_t& value) override {
		emit signal_attribute(value);
	};

	virtual void endOfPipe() override {
		emit signal_endOfPipe();
	};

signals:
	void signal_startRelation(string_t name, std::vector<AttributeMetadata> attributes);
	void signal_attribute(const string_t& value);
	void signal_endOfPipe();

private slots:

	void slot_startRelation(string_t name, std::vector<AttributeMetadata> attributes) {
		target->startRelation(name, attributes);
	};

	void slot_attribute(const string_t& value) {
		target->attribute(value);
	};

	void slot_endOfPipe() {
		target->endOfPipe();
	};
};

Jde mi o to, že mám rozhraní RelationalReaderStringHadler a toto rozhraní mi provolává metoda, která parsuje vstup. V CLI aplikaci to můžu napojit napřímo, ale tady jsem mezi to musel vložit ještě tu "proxy" QtRelationalReaderStringHadler, která to prožene přes signály/sloty a tím zajistí, že se data mezi dvěma vlákny předají správně. Napadá vás nějaké elegantnější řešení?

V dokumentaci Qt jsem našel, že to jde napojovat i na std::bind nebo lambdu, což by trošku kódu ušetřilo (mohl bych kód slotů předat do QObject::connect() jako funkci). Nešlo by to napojit nějak automaticky? Protože ta rozhraní jsou v obou vláknech totožná.

Případně by se mi líbilo, kdybych mohl v těch metodách místo emit signal_... jen předat někam lambdu s tím, že se má provést v GUI vlákně. (to bych si asi zvládl napsat sám a protáhnout všechna volání přes jeden signál/slot, ale nechci vymýšlet kolo a radši bych se naučil nějaký standardní postup).