cxx-qt 0.9.1

Safe interop between Rust and Qt
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

// clang-format off
// SPDX-FileCopyrightText: 2022 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
// clang-format on
// SPDX-FileContributor: Andrew Hayzen <andrew.hayzen@kdab.com>
//
// SPDX-License-Identifier: MIT OR Apache-2.0
#pragma once

#include <cstdint>
#include <iostream>
#include <memory>
#include <mutex>
#include <shared_mutex>
#include <stdexcept>

#include <QtCore/QDebug>
#include <QtCore/QMetaObject>

#include "rust/cxx.h"

namespace rust {
namespace cxxqt1 {

template<typename T>
class CxxQtGuardedPointer final
{
public:
  explicit CxxQtGuardedPointer(T* ptr)
    : ptr(ptr)
  {
  }

  T* ptr;
  ::std::shared_mutex mutex;
};

template<typename T>
class CxxQtThread final
{
public:
  CxxQtThread(::std::shared_ptr<CxxQtGuardedPointer<T>> obj)
    : m_obj(obj)
  {
  }

  ~CxxQtThread() = default;
  CxxQtThread(const CxxQtThread<T>& other) = default;
  CxxQtThread(CxxQtThread<T>&& other) = default;

  bool isDestroyed() const
  {
    const auto guard = ::std::shared_lock(m_obj->mutex);
    return m_obj->ptr == nullptr;
  }

  template<typename A>
  ::std::uint8_t queue(::rust::Fn<void(T& self, ::rust::Box<A> arg)> func,
                       ::rust::Box<A> arg) const
  {
    const static ::std::uint8_t sObjectDestroyed = 1;
    const static ::std::uint8_t sInvokeMethodFailed = 2;

    // Ensure that we can read the pointer and it's not being written to
    const auto guard = ::std::shared_lock(m_obj->mutex);
    if (!m_obj->ptr) {
      return sObjectDestroyed;
    }

    // Construct the lambda
    auto obj = m_obj;
    auto lambda = [obj = ::std::move(obj),
                   func = ::std::move(func),
                   arg = ::std::move(arg)]() mutable {
      // Ensure that we can read the pointer and it's not being written to
      const auto guard = ::std::shared_lock(obj->mutex);
      if (obj->ptr) {
        func(*obj->ptr, ::std::move(arg));
      } else {
        qWarning()
          << "Could not call the function pointer as object has been destroyed";
      }
    };

    // Add the lambda to the queue
    if (!QMetaObject::invokeMethod(
          m_obj->ptr, ::std::move(lambda), Qt::QueuedConnection)) {
      return sInvokeMethodFailed;
    }

    return 0;
  }

private:
  ::std::shared_ptr<CxxQtGuardedPointer<T>> m_obj;
};

template<typename T>
CxxQtThread<T>
cxxQtThreadClone(const CxxQtThread<T>& cxxQtThread)
{
  return CxxQtThread<T>(cxxQtThread);
}

template<typename T>
void
cxxQtThreadDrop(CxxQtThread<T>& cxxQtThread)
{
  cxxQtThread.~CxxQtThread<T>();
}

template<typename A, typename T>
::std::uint8_t
cxxQtThreadQueue(const CxxQtThread<T>& cxxQtThread,
                 ::rust::Fn<void(T& self, ::rust::Box<A> arg)> func,
                 ::rust::Box<A> arg)
{
  return cxxQtThread.queue(::std::move(func), ::std::move(arg));
}

template<typename T>
bool
cxxQtThreadIsDestroyed(const CxxQtThread<T>& cxxQtThread)
{
  return cxxQtThread.isDestroyed();
}

} // namespace cxxqt1
} // namespace rust

// Define namespace otherwise we hit a GCC bug
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56480
namespace rust {

template<typename T>
struct IsRelocatable<::rust::cxxqt1::CxxQtThread<T>> : ::std::true_type
{};

} // namespace rust