split project with app & doric module

doric-Qt/example/doric/async/DoricAsyncCall.h

@@ -0,0 +1,26 @@
+#ifndef ASYNC_CALL_H
+#define ASYNC_CALL_H
+
+#include <QFuture>
+#include <QThreadPool>
+#include <QtConcurrent/QtConcurrent>
+
+class DoricAsyncCall {
+
+public:
+  static void ensureRunInThreadPool(QThreadPool *threadPool,
+                                    std::function<void()> lambda) {
+    QFuture<std::function<void()>::result_type> future =
+        QtConcurrent::run(threadPool, lambda);
+  }
+
+  template <typename Function>
+  static void ensureRunInMain(Function &&function,
+                              QThread *thread = qApp->thread()) {
+    auto *obj = QAbstractEventDispatcher::instance(thread);
+    Q_ASSERT(obj);
+    QMetaObject::invokeMethod(obj, std::forward<Function>(function));
+  }
+};
+
+#endif // ASYNC_CALL_H

doric-Qt/example/doric/async/DoricAsyncResult.cpp

@@ -0,0 +1,38 @@
+#include "DoricAsyncResult.h"
+
+DoricAsyncResult::DoricAsyncResult() {}
+
+DoricAsyncResult::DoricAsyncResult(QJSValue result) { this->result = result; }
+
+void DoricAsyncResult::setResult(QJSValue result) {
+  this->result = result;
+  if (this->callback != NULL) {
+    this->callback->onResult(result);
+    this->callback->onFinish();
+  }
+}
+
+void DoricAsyncResult::setError(QJSValue exception) {
+  this->result = exception;
+  if (this->callback != NULL) {
+    this->callback->onResult(result);
+    this->callback->onFinish();
+  }
+}
+
+bool DoricAsyncResult::hasResult() { return !result.equals(EMPTY); }
+
+QJSValue DoricAsyncResult::getResult() { return this->result; }
+
+void DoricAsyncResult::setCallback(DoricCallback *callback) {
+  this->callback = callback;
+  if (this->result.isError()) {
+    this->callback->onError(result);
+    this->callback->onFinish();
+  } else if (!result.equals(EMPTY)) {
+    this->callback->onResult(result);
+    this->callback->onFinish();
+  }
+}
+
+DoricSettableFuture *DoricAsyncResult::synchronous() { return NULL; }

doric-Qt/example/doric/async/DoricAsyncResult.h

@@ -0,0 +1,34 @@
+#ifndef ASYNCRESULT_H
+#define ASYNCRESULT_H
+
+#include <QJSValue>
+
+#include "DoricCallback.h"
+#include "DoricSettableFuture.h"
+
+static QJSValue EMPTY(QJSValue::NullValue);
+
+class DoricAsyncResult {
+private:
+  QJSValue result = EMPTY;
+  DoricCallback *callback;
+
+public:
+  DoricAsyncResult();
+
+  DoricAsyncResult(QJSValue result);
+
+  void setResult(QJSValue result);
+
+  void setError(QJSValue exception);
+
+  bool hasResult();
+
+  QJSValue getResult();
+
+  void setCallback(DoricCallback *callback);
+
+  DoricSettableFuture *synchronous();
+};
+
+#endif // ASYNCRESULT_H

doric-Qt/example/doric/async/DoricCallback.h

@@ -0,0 +1,15 @@
+#ifndef CALLBACK_H
+#define CALLBACK_H
+
+#include <QJSValue>
+
+class DoricCallback {
+public:
+  virtual void onResult(QJSValue result) = 0;
+
+  virtual void onError(QJSValue error) = 0;
+
+  virtual void onFinish() = 0;
+};
+
+#endif // CALLBACK_H

doric-Qt/example/doric/async/DoricSettableFuture.cpp

@@ -0,0 +1,17 @@
+#include <QDebug>
+
+#include "DoricSettableFuture.h"
+
+void DoricSettableFuture::set(QJSValue result) {
+  if (mReadyLatch == NULL) {
+    qDebug() << "Result has already been set!";
+    return;
+  }
+  mResult = result;
+  delete mReadyLatch;
+}
+
+QJSValue DoricSettableFuture::get() {
+  mReadyLatch->lock();
+  return mResult;
+}

doric-Qt/example/doric/async/DoricSettableFuture.h

@@ -0,0 +1,19 @@
+#ifndef SETTABLE_FUTURE_H
+#define SETTABLE_FUTURE_H
+
+#include <QJSValue>
+
+#include "utils/DoricCountDownLatch.h"
+
+class DoricSettableFuture {
+private:
+  QJSValue mResult;
+  DoricCountDownLatch *mReadyLatch = new DoricCountDownLatch();
+
+public:
+  void set(QJSValue result);
+
+  QJSValue get();
+};
+
+#endif // SETTABLE_FUTURE_H