Skip to content

Commit 69cd338

Browse files
ahayzen-kdabahayzen-kdab
committed
WIP: cxx-qt-gen: add more variants for snapshot test of cfgs
1 parent a715d3b commit 69cd338

File tree

4 files changed

+1295
-124
lines changed

4 files changed

+1295
-124
lines changed

‎crates/cxx-qt-gen/test_inputs/cfgs.rs‎

Lines changed: 108 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -1,38 +1,136 @@
11
#[cxx_qt::bridge]
22
mod ffi {
3-
#[qenum(MyObject)]
3+
// Enabled C++Qt QObject
4+
// - disabled and enabled qsignal
5+
unsafe extern "C++Qt" {
6+
#[qobject]
7+
#[cfg(enabled)]
8+
type QObjectExternEnabled;
9+
10+
#[qsignal]
11+
#[cfg(not(enabled))]
12+
fn signal_disabled1(self: Pin<&mut QObjectExternEnabled>);
13+
14+
#[qsignal]
15+
#[cfg(enabled)]
16+
fn signal_enabled1(self: Pin<&mut QObjectExternEnabled>);
17+
}
18+
19+
// Disabled C++Qt QObject
20+
// - disabled and enabled qsignal
21+
unsafe extern "C++Qt" {
22+
#[qobject]
23+
#[cfg(not(enabled))]
24+
type QObjectExternDisabled;
25+
26+
#[qsignal]
27+
#[cfg(not(enabled))]
28+
fn signal_disabled2(self: Pin<&mut QObjectExternDisabled>);
29+
30+
#[qsignal]
31+
#[cfg(enabled)]
32+
fn signal_enabled2(self: Pin<&mut QObjectExternDisabled>);
33+
}
34+
35+
// Enabled RustQt QObject
36+
// - disabled and enabled qenum
37+
38+
#[qenum(QObjectEnabled)]
439
#[cfg(not(enabled))]
5-
enum EnumDisabled {
40+
enum EnumDisabled1 {
641
A,
742
}
843

9-
unsafe extern "C++Qt" {
44+
#[qenum(QObjectEnabled)]
45+
#[cfg(enabled)]
46+
enum EnumEnabled1 {
47+
A,
48+
}
49+
50+
// Enabled RustQt QObject
51+
// - disabled and enabled inherit
52+
// - disabled and enabled invokable
53+
// - disabled and enabled signal
54+
unsafe extern "RustQt" {
1055
#[qobject]
56+
#[cfg(enabled)]
57+
// TODO: should we allow for disabling properties?
58+
// #[qproperty(i32, property_disabled, cfg(not(enabled)))]
59+
type QObjectEnabled = super::QObjectEnabledRust;
60+
61+
#[inherit]
62+
#[cfg(not(enabled))]
63+
fn inherit_disabled(self: &QObjectEnabled);
64+
65+
#[inherit]
66+
#[cfg(enabled)]
67+
fn inherit_enabled(self: &QObjectEnabled);
68+
69+
#[qinvokable]
1170
#[cfg(not(enabled))]
12-
type QTimer;
71+
fn invokable_disabled(self: &QObjectEnabled);
72+
73+
#[qinvokable]
74+
#[cfg(enabled)]
75+
fn invokable_enabled(self: &QObjectEnabled);
1376

1477
#[qsignal]
1578
#[cfg(not(enabled))]
16-
fn timeout(self: Pin<&mut QTimer>);
79+
fn signal_disabled(self: Pin<&mut QObjectEnabled>);
80+
81+
#[qsignal]
82+
#[cfg(enabled)]
83+
fn signal_enabled(self: Pin<&mut QObjectEnabled>);
84+
}
85+
86+
// Dislabed RustQt QObject
87+
// - disabled and enabled qenum
88+
89+
#[qenum(QObjectDisabled)]
90+
#[cfg(not(enabled))]
91+
enum EnumDisabled2 {
92+
A,
1793
}
1894

95+
#[qenum(QObjectDisabled)]
96+
#[cfg(enabled)]
97+
enum EnumEnabled2 {
98+
A,
99+
}
100+
101+
// Disabled RustQt QObject
102+
// - disabled and enabled inherit
103+
// - disabled and enabled invokable
104+
// - disabled and enabled signal
19105
unsafe extern "RustQt" {
20-
// TODO: should we allow for disabling qobjects?
21106
#[qobject]
107+
#[cfg(not(enabled))]
22108
// TODO: should we allow for disabling properties?
23109
// #[qproperty(i32, property_disabled, cfg(not(enabled)))]
24-
type MyObject = super::MyObjectRust;
110+
type QObjectDisabled = super::QObjectDisabledRust;
25111

26112
#[inherit]
27113
#[cfg(not(enabled))]
28-
fn inherit_disabled(self: &MyObject);
114+
fn inherit_disabled(self: &QObjectDisabled);
115+
116+
#[inherit]
117+
#[cfg(enabled)]
118+
fn inherit_enabled(self: &QObjectDisabled);
29119

30120
#[qinvokable]
31121
#[cfg(not(enabled))]
32-
fn invokable_disabled(self: &MyObject);
122+
fn invokable_disabled(self: &QObjectDisabled);
123+
124+
#[qinvokable]
125+
#[cfg(enabled)]
126+
fn invokable_enabled(self: &QObjectDisabled);
33127

34128
#[qsignal]
35129
#[cfg(not(enabled))]
36-
fn signal_disabled(self: Pin<&mut MyObject>);
130+
fn signal_disabled(self: Pin<&mut QObjectDisabled>);
131+
132+
#[qsignal]
133+
#[cfg(enabled)]
134+
fn signal_enabled(self: Pin<&mut QObjectDisabled>);
37135
}
38136
}

‎crates/cxx-qt-gen/test_outputs/cfgs.cpp‎

Lines changed: 174 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,179 @@
11
#include "directory/file_ident.cxxqt.h"
22

3-
MyObject::MyObject(QObject* parent)
3+
// Define namespace otherwise we hit a GCC bug
4+
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56480
5+
namespace rust::cxxqt1 {
6+
template<>
7+
SignalHandler<
8+
::rust::cxxqtgen1::QObjectExternEnabledCxxQtSignalParamssignal_enabled1*>::
9+
~SignalHandler() noexcept
10+
{
11+
if (data[0] == nullptr && data[1] == nullptr) {
12+
return;
13+
}
14+
15+
drop_QObjectExternEnabled_signal_handler_signal_enabled1(::std::move(*this));
16+
}
17+
18+
template<>
19+
template<>
20+
void
21+
SignalHandler<
22+
::rust::cxxqtgen1::QObjectExternEnabledCxxQtSignalParamssignal_enabled1*>::
23+
operator()<QObjectExternEnabled&>(QObjectExternEnabled& self)
24+
{
25+
call_QObjectExternEnabled_signal_handler_signal_enabled1(*this, self);
26+
}
27+
28+
static_assert(
29+
alignof(
30+
SignalHandler<::rust::cxxqtgen1::
31+
QObjectExternEnabledCxxQtSignalParamssignal_enabled1*>) <=
32+
alignof(::std::size_t),
33+
"unexpected aligment");
34+
static_assert(
35+
sizeof(
36+
SignalHandler<::rust::cxxqtgen1::
37+
QObjectExternEnabledCxxQtSignalParamssignal_enabled1*>) ==
38+
sizeof(::std::size_t[2]),
39+
"unexpected size");
40+
} // namespace rust::cxxqt1
41+
42+
namespace rust::cxxqtgen1 {
43+
::QMetaObject::Connection
44+
QObjectExternEnabled_signal_enabled1Connect(
45+
QObjectExternEnabled& self,
46+
::rust::cxxqtgen1::QObjectExternEnabledCxxQtSignalHandlersignal_enabled1
47+
closure,
48+
::Qt::ConnectionType type)
49+
{
50+
return ::QObject::connect(
51+
&self,
52+
&QObjectExternEnabled::signal_enabled1,
53+
&self,
54+
[&, closure = ::std::move(closure)]() mutable {
55+
closure.template operator()<QObjectExternEnabled&>(self);
56+
},
57+
type);
58+
}
59+
} // namespace rust::cxxqtgen1
60+
61+
// Define namespace otherwise we hit a GCC bug
62+
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56480
63+
namespace rust::cxxqt1 {
64+
template<>
65+
SignalHandler<
66+
::rust::cxxqtgen1::QObjectExternDisabledCxxQtSignalParamssignal_enabled2*>::
67+
~SignalHandler() noexcept
68+
{
69+
if (data[0] == nullptr && data[1] == nullptr) {
70+
return;
71+
}
72+
73+
drop_QObjectExternDisabled_signal_handler_signal_enabled2(::std::move(*this));
74+
}
75+
76+
template<>
77+
template<>
78+
void
79+
SignalHandler<
80+
::rust::cxxqtgen1::QObjectExternDisabledCxxQtSignalParamssignal_enabled2*>::
81+
operator()<QObjectExternDisabled&>(QObjectExternDisabled& self)
82+
{
83+
call_QObjectExternDisabled_signal_handler_signal_enabled2(*this, self);
84+
}
85+
86+
static_assert(
87+
alignof(
88+
SignalHandler<::rust::cxxqtgen1::
89+
QObjectExternDisabledCxxQtSignalParamssignal_enabled2*>) <=
90+
alignof(::std::size_t),
91+
"unexpected aligment");
92+
static_assert(
93+
sizeof(
94+
SignalHandler<::rust::cxxqtgen1::
95+
QObjectExternDisabledCxxQtSignalParamssignal_enabled2*>) ==
96+
sizeof(::std::size_t[2]),
97+
"unexpected size");
98+
} // namespace rust::cxxqt1
99+
100+
namespace rust::cxxqtgen1 {
101+
::QMetaObject::Connection
102+
QObjectExternDisabled_signal_enabled2Connect(
103+
QObjectExternDisabled& self,
104+
::rust::cxxqtgen1::QObjectExternDisabledCxxQtSignalHandlersignal_enabled2
105+
closure,
106+
::Qt::ConnectionType type)
107+
{
108+
return ::QObject::connect(
109+
&self,
110+
&QObjectExternDisabled::signal_enabled2,
111+
&self,
112+
[&, closure = ::std::move(closure)]() mutable {
113+
closure.template operator()<QObjectExternDisabled&>(self);
114+
},
115+
type);
116+
}
117+
} // namespace rust::cxxqtgen1
118+
119+
// Define namespace otherwise we hit a GCC bug
120+
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56480
121+
namespace rust::cxxqt1 {
122+
template<>
123+
SignalHandler<
124+
::rust::cxxqtgen1::QObjectEnabledCxxQtSignalParamssignal_enabled*>::
125+
~SignalHandler() noexcept
126+
{
127+
if (data[0] == nullptr && data[1] == nullptr) {
128+
return;
129+
}
130+
131+
drop_QObjectEnabled_signal_handler_signal_enabled(::std::move(*this));
132+
}
133+
134+
template<>
135+
template<>
136+
void
137+
SignalHandler<
138+
::rust::cxxqtgen1::QObjectEnabledCxxQtSignalParamssignal_enabled*>::
139+
operator()<QObjectEnabled&>(QObjectEnabled& self)
140+
{
141+
call_QObjectEnabled_signal_handler_signal_enabled(*this, self);
142+
}
143+
144+
static_assert(
145+
alignof(SignalHandler<
146+
::rust::cxxqtgen1::QObjectEnabledCxxQtSignalParamssignal_enabled*>) <=
147+
alignof(::std::size_t),
148+
"unexpected aligment");
149+
static_assert(
150+
sizeof(SignalHandler<
151+
::rust::cxxqtgen1::QObjectEnabledCxxQtSignalParamssignal_enabled*>) ==
152+
sizeof(::std::size_t[2]),
153+
"unexpected size");
154+
} // namespace rust::cxxqt1
155+
156+
namespace rust::cxxqtgen1 {
157+
::QMetaObject::Connection
158+
QObjectEnabled_signal_enabledConnect(
159+
QObjectEnabled& self,
160+
::rust::cxxqtgen1::QObjectEnabledCxxQtSignalHandlersignal_enabled closure,
161+
::Qt::ConnectionType type)
162+
{
163+
return ::QObject::connect(
164+
&self,
165+
&QObjectEnabled::signal_enabled,
166+
&self,
167+
[&, closure = ::std::move(closure)]() mutable {
168+
closure.template operator()<QObjectEnabled&>(self);
169+
},
170+
type);
171+
}
172+
} // namespace rust::cxxqtgen1
173+
174+
QObjectEnabled::QObjectEnabled(QObject* parent)
4175
: QObject(parent)
5-
, ::rust::cxxqt1::CxxQtType<MyObjectRust>(::cxx_qt_MyObject::createRs())
176+
, ::rust::cxxqt1::CxxQtType<QObjectEnabledRust>(
177+
::cxx_qt_QObjectEnabled::createRs())
6178
{
7179
}

0 commit comments

Comments
 (0)