QuickStreams (PoC)

A proof of concept implementation of an asynchronous programming library for the QML and C++ programming languages inspired by Reactive Extensions, implementing the asynchronous streams paradigm.

IMPORTANT NOTE: QuickStreams is an asynchronous programming experiment. Work on this particular repository was suspended due to lack of feedback. It's not yet clear whether the concept of programming in streams is relevant.

Asynchronous Programming in Streams

QuickStreams makes asynchronous programming in C++ & QML easier and safer by providing a way to build consistent abstractions of complex asynchronous operations and transactions.

In contrast to Qt Quick's low level Signals & Slots mechanism, primitive Callbacks and the more sophisticated Promises and Futures - Streams are suitable for a much wider spectrum of problems and also offer a much wider set of useful features.

Streams can...

• abstract away asynchronous (abortable and atomic) operations and transactions
• be chained into asynchronous sequences
• abstract away sequences of other streams
• safely recover from unexpected errors
• be retried on expected errors
• be aborted
• be repeated conditionally (asynchronous loops)
• emit events

For a more detailed description, please visit qbeon.github.io/QuickStreams

Installation

1. Clone this repository or download a release version to a folder within your projects source tree.

2. Add the QuickStreams.pri file to your project profile .pro file:

include(QuickStreams/QuickStreams.pri) # optionally adjust the path

3. Create a quickstreams::Provider object and inject it (by reference) into any C++ component to create streams in. Optionally create a quickstreams::qml::QmlProvider and expose it to QML as a context property to create streams in QML:

// in your projects main.cpp

#include <QuickStreams>

int main() {
	//...
	
	auto engine(new QQmlApplicationEngine);

	// Create a streams provider
	auto provider(new quickstreams::Provider);

	// Create a new QML streams provider wrapping a regular streams provider.
	auto qmlProvider(new quickstreams::qml::QmlProvider(engine, provider));
	
	// Expose the QML streams provider to QML
	// to enable streams creation from from QML
	engine.rootContext()->setContextProperty("QuickStreams", qmlProvider);
	
	//...
}

quickstreams::qml::QmlProvider should be injected (by reference) into C++ components exposing APIs to QML.

Examples

• Network Filesystem API - A network filesystem simulation implemented in pure QML JavaScript. Represents the unreliable, asynchronous filesystem API in streams.

• C++ API exposed to QML - Similar to the network filesystem API example, but implements the network filesystem API in C++ exposing it to QML using the quickstreams::qml::QmlProvider.

For a detailed description of the streams programming paradigm, use cases and features, please visit qbeon.github.io/QuickStreams

Feedback, Help & Contribution

• Ask questions and follow discussions on Stack Overflow, QtMob, Telegram (RU)
• Request new features and report bugs in GitHub Issues.
• Or contact us directly via contact@qbeon.com

License

Copyright (c) Roman Sharkov. All rights reserved.

Licensed under the MIT License.