init

cmake/external/glib/cppgir/examples/gio-qt-async.cpp

@@ -0,0 +1,225 @@
+#define GI_INLINE 1
+#include <gio/gio.hpp>
+
+#include <functional>
+#include <iostream>
+#include <memory>
+
+#include <QCoreApplication>
+
+#include <QFuture>
+#include <QFutureWatcher>
+#include <QObject>
+
+namespace GLib = gi::repository::GLib;
+namespace GObject_ = gi::repository::GObject;
+namespace Gio = gi::repository::Gio;
+
+template<typename T>
+using ResultExtractor = std::function<void(
+    GObject_::Object, Gio::AsyncResult result, QFutureInterface<T> &fut)>;
+
+template<typename T>
+class qt_future
+{
+  struct CallbackData
+  {
+    QFutureInterface<T> promise;
+    QFutureWatcher<T> watcher;
+    Gio::Cancellable cancel;
+    ResultExtractor<T> handler;
+  };
+
+  std::shared_ptr<CallbackData> data_;
+
+public:
+  qt_future(ResultExtractor<T> h)
+  {
+    data_ = std::make_shared<CallbackData>();
+    data_->handler = h;
+  }
+
+  QFuture<T> future() { return data_->promise.future(); }
+
+  QFutureInterface<T> promise() { return data_->promise; }
+
+  operator Gio::AsyncReadyCallback()
+  {
+    auto d = data_;
+    return [d](GObject_::Object obj, Gio::AsyncResult result) {
+      assert(d->handler);
+      d->handler(obj, result, d->promise);
+    };
+  }
+
+  Gio::Cancellable cancellable()
+  {
+    if (!data_->cancel) {
+      auto cancel = data_->cancel = Gio::Cancellable::new_();
+      data_->watcher.setFuture(future());
+      auto h = [cancel]() mutable { cancel.cancel(); };
+      data_->watcher.connect(
+          &data_->watcher, &decltype(data_->watcher)::finished, std::move(h));
+    }
+    return data_->cancel;
+  }
+
+  // why not ... ??
+  operator Gio::Cancellable() { return cancellable(); }
+};
+
+#if GI_CONST_METHOD
+#define CONST_METHOD const
+#else
+#define CONST_METHOD
+#endif
+
+template<typename Result, typename Object>
+qt_future<Result>
+make_future(Result (Object::*mf)(Gio::AsyncResult, GLib::Error *) CONST_METHOD)
+{
+  ResultExtractor<Result> f;
+  f = [mf](GObject_::Object cbobj, Gio::AsyncResult result,
+          QFutureInterface<Result> &fut) mutable {
+    auto obj = gi::object_cast<Object>(cbobj);
+    GLib::Error error{};
+    auto res = (obj.*mf)(result, &error);
+    if (error.gobj_()) {
+      // FIXME use std::expected<Result> as a result type ??
+      // reportException might be an option, if enabled, but leads to throw
+      fut.reportFinished();
+      qWarning() << "error code " << error.code_();
+      qWarning() << "error message "
+                 << QString::fromUtf8(error.message_().c_str());
+    } else {
+      fut.reportFinished(&res);
+    }
+  };
+  return {f};
+}
+
+// ====
+// some small future-centric API wrappers using above helper class
+
+QFuture<Gio::FileInfo>
+file_query_file_system_info(
+    Gio::File f, const std::string &attributes, gint io_priority)
+{
+  auto fut = make_future(&Gio::File::query_filesystem_info_finish);
+  f.query_filesystem_info_async(attributes, io_priority, fut, fut);
+  return fut.future();
+}
+
+QFuture<bool>
+file_copy(Gio::File src, Gio::File destination, Gio::FileCopyFlags flags,
+    gint io_priority)
+{
+  auto fut = make_future(&Gio::File::copy_finish);
+  auto promise = fut.promise();
+  auto p = [promise](
+               goffset current_num_bytes, goffset total_num_bytes) mutable {
+    promise.setProgressRange(0, total_num_bytes);
+    promise.setProgressValue(current_num_bytes);
+  };
+  src.copy_async(destination, flags, io_priority, fut, p, fut);
+  return fut.future();
+}
+
+// ====
+
+// save on typing elsewhere
+// also makes it movable in a way
+template<typename T>
+std::shared_ptr<QFutureWatcher<T>>
+make_watcher(QFuture<T> fut)
+{
+  auto watcher = std::make_shared<QFutureWatcher<T>>();
+  watcher->setFuture(fut);
+  return watcher;
+}
+
+// type-erased owner/cleanup type
+using Retainer = std::shared_ptr<std::nullptr_t>;
+
+Retainer
+do_query(QCoreApplication &app, const std::string &fpath)
+{
+  auto file = Gio::File::new_for_commandline_arg(fpath);
+  auto fut = file_query_file_system_info(file, "*", GLib::PRIORITY_DEFAULT_);
+  auto watcher = make_watcher(fut);
+  auto h = [fut, &app]() {
+    Q_ASSERT(fut.isFinished());
+    std::cout << "query finished" << std::endl;
+    if (fut.resultCount()) {
+      auto finfo = fut.result();
+      for (auto attr : {Gio::FILE_ATTRIBUTE_FILESYSTEM_TYPE_,
+               Gio::FILE_ATTRIBUTE_FILESYSTEM_FREE_,
+               Gio::FILE_ATTRIBUTE_FILESYSTEM_SIZE_}) {
+        std::cout << attr << ": " << finfo.get_attribute_as_string(attr)
+                  << std::endl;
+      }
+    } else {
+      std::cout << "... but no results" << std::endl;
+    }
+    app.quit();
+  };
+  watcher->connect(
+      watcher.get(), &decltype(watcher)::element_type::finished, &app, h);
+  return {watcher, nullptr};
+}
+
+Retainer
+do_copy(QCoreApplication &app, const std::string &src, const std::string &dest)
+{
+  auto fsrc = Gio::File::new_for_commandline_arg(src);
+  auto fdest = Gio::File::new_for_commandline_arg(dest);
+  auto fut = file_copy(
+      fsrc, fdest, Gio::FileCopyFlags::ALL_METADATA_, GLib::PRIORITY_DEFAULT_);
+  auto watcher = make_watcher(fut);
+  auto h = [fut, &app]() {
+    Q_ASSERT(fut.isFinished());
+    std::cout << "copy finished" << std::endl;
+    if (fut.resultCount()) {
+      auto ok = fut.result();
+      if (ok) {
+        std::cout << "copy ok" << std::endl;
+      } else {
+        std::cout << "copy failed" << std::endl;
+      }
+    } else {
+      std::cout << "... but no results" << std::endl;
+    }
+    app.quit();
+  };
+  watcher->connect(
+      watcher.get(), &decltype(watcher)::element_type::finished, &app, h);
+  // also monitor progress
+  auto progress = [fut](int) {
+    auto max = fut.progressMaximum();
+    auto min = fut.progressMinimum();
+    auto current = fut.progressValue();
+    std::cout << "copy progress " << current << " (" << min << " -> " << max
+              << ")" << std::endl;
+  };
+  watcher->connect(watcher.get(),
+      &decltype(watcher)::element_type::progressValueChanged, &app, progress);
+  return {watcher, nullptr};
+}
+
+int
+main(int argc, char **argv)
+{
+  QCoreApplication app(argc, argv);
+
+  if (argc < 2)
+    return -1;
+
+  Retainer r;
+  if (argc == 2) {
+    r = do_query(app, argv[1]);
+  } else if (argc == 3) {
+    r = do_copy(app, argv[1], argv[2]);
+  }
+
+  return app.exec();
+}