From b8647255aafb68c934b2559aa85606b58e00dc86 Mon Sep 17 00:00:00 2001 From: Andrew Hayzen Date: Thu, 3 Nov 2022 19:05:52 +0000 Subject: [PATCH 1/4] cxx-qt-lib: define a QSet with QSetElement trait Also define all primitive types and cxx_qt_lib types as T. Related to #347 --- CHANGELOG.md | 1 + book/src/concepts/types.md | 13 + crates/cxx-qt-lib-headers/include/qset.h | 63 +++++ crates/cxx-qt-lib-headers/src/lib.rs | 3 +- crates/cxx-qt-lib/build.rs | 43 ++- crates/cxx-qt-lib/src/types/mod.rs | 3 + crates/cxx-qt-lib/src/types/qset/generate.sh | 110 ++++++++ crates/cxx-qt-lib/src/types/qset/mod.rs | 258 ++++++++++++++++++ crates/cxx-qt-lib/src/types/qset/qset.cpp | 97 +++++++ crates/cxx-qt-lib/src/types/qset/qset_bool.rs | 35 +++ crates/cxx-qt-lib/src/types/qset/qset_f32.rs | 35 +++ crates/cxx-qt-lib/src/types/qset/qset_f64.rs | 35 +++ crates/cxx-qt-lib/src/types/qset/qset_i16.rs | 35 +++ crates/cxx-qt-lib/src/types/qset/qset_i32.rs | 35 +++ crates/cxx-qt-lib/src/types/qset/qset_i8.rs | 35 +++ .../cxx-qt-lib/src/types/qset/qset_qdate.rs | 37 +++ .../src/types/qset/qset_qdatetime.rs | 37 +++ .../cxx-qt-lib/src/types/qset/qset_qstring.rs | 37 +++ .../cxx-qt-lib/src/types/qset/qset_qtime.rs | 37 +++ crates/cxx-qt-lib/src/types/qset/qset_qurl.rs | 37 +++ crates/cxx-qt-lib/src/types/qset/qset_u16.rs | 35 +++ crates/cxx-qt-lib/src/types/qset/qset_u32.rs | 35 +++ crates/cxx-qt-lib/src/types/qset/qset_u8.rs | 35 +++ tests/qt_types_standalone/CMakeLists.txt | 1 + tests/qt_types_standalone/cpp/main.cpp | 2 + tests/qt_types_standalone/cpp/qset.h | 51 ++++ tests/qt_types_standalone/rust/build.rs | 1 + tests/qt_types_standalone/rust/src/lib.rs | 1 + tests/qt_types_standalone/rust/src/qset.rs | 44 +++ 29 files changed, 1184 insertions(+), 7 deletions(-) create mode 100644 crates/cxx-qt-lib-headers/include/qset.h create mode 100755 crates/cxx-qt-lib/src/types/qset/generate.sh create mode 100644 crates/cxx-qt-lib/src/types/qset/mod.rs create mode 100644 crates/cxx-qt-lib/src/types/qset/qset.cpp create mode 100644 crates/cxx-qt-lib/src/types/qset/qset_bool.rs create mode 100644 crates/cxx-qt-lib/src/types/qset/qset_f32.rs create mode 100644 crates/cxx-qt-lib/src/types/qset/qset_f64.rs create mode 100644 crates/cxx-qt-lib/src/types/qset/qset_i16.rs create mode 100644 crates/cxx-qt-lib/src/types/qset/qset_i32.rs create mode 100644 crates/cxx-qt-lib/src/types/qset/qset_i8.rs create mode 100644 crates/cxx-qt-lib/src/types/qset/qset_qdate.rs create mode 100644 crates/cxx-qt-lib/src/types/qset/qset_qdatetime.rs create mode 100644 crates/cxx-qt-lib/src/types/qset/qset_qstring.rs create mode 100644 crates/cxx-qt-lib/src/types/qset/qset_qtime.rs create mode 100644 crates/cxx-qt-lib/src/types/qset/qset_qurl.rs create mode 100644 crates/cxx-qt-lib/src/types/qset/qset_u16.rs create mode 100644 crates/cxx-qt-lib/src/types/qset/qset_u32.rs create mode 100644 crates/cxx-qt-lib/src/types/qset/qset_u8.rs create mode 100644 tests/qt_types_standalone/cpp/qset.h create mode 100644 tests/qt_types_standalone/rust/src/qset.rs diff --git a/CHANGELOG.md b/CHANGELOG.md index eee0213e6..c87a4dc53 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -19,6 +19,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Added - Multiple QObjects can be defined in one bridge +- Support for container types: `QSet` ### Fixed diff --git a/book/src/concepts/types.md b/book/src/concepts/types.md index e74ff92bc..f67476a80 100644 --- a/book/src/concepts/types.md +++ b/book/src/concepts/types.md @@ -17,6 +17,19 @@ The `cxx-qt-lib` crate provides CXX bindings for common Qt types. Use the [`cxx-qt-lib` Docs](https://docs.rs/cxx-qt-lib/latest/cxx_qt_lib/) to explore the available types. +### Container Types + +The `cxx-qt-lib` crate has containers types, such as `QSet`. + +To use these define a templated type in the CXX bridge, but note that the type +name must be `QSet_T` as this needs to match the name in C++ code. + +So for `QSet` the type name should be `QSet_i32`. + +```rust,ignore +{{#include ../../../tests/qt_types_standalone/rust/src/qset.rs:book_qset}} +``` + ## Defining a Custom Type Any types that are valid CXX types should be usable with CXX-Qt as well. diff --git a/crates/cxx-qt-lib-headers/include/qset.h b/crates/cxx-qt-lib-headers/include/qset.h new file mode 100644 index 000000000..4a1c4511a --- /dev/null +++ b/crates/cxx-qt-lib-headers/include/qset.h @@ -0,0 +1,63 @@ +// clang-format off +// SPDX-FileCopyrightText: 2022 Klarälvdalens Datakonsult AB, a KDAB Group company +// clang-format on +// SPDX-FileContributor: Andrew Hayzen +// +// SPDX-License-Identifier: MIT OR Apache-2.0 +#pragma once + +#include + +#include +#include +#include +#include +#include + +#include "rust/cxx.h" + +// This has static asserts in the cpp file to ensure this is valid. +template +struct rust::IsRelocatable> : std::true_type +{ +}; + +// Note on the Rust side we rename the methods to "clear" or "len" etc +// so we need to put each set in it's own namespace otherwise the generated +// CXX code collides. +#define CXX_QT_QSET_METHODS(typeName, name) \ + using QSet_##name = QSet; \ + \ + namespace rust { \ + namespace cxxqtlib1 { \ + namespace qset_##name \ + { \ + void qset_clear_##name(QSet_##name& s) noexcept; \ + QSet_##name qset_clone_##name(const QSet_##name& s) noexcept; \ + bool qset_contains_##name(const QSet_##name& s, \ + const typeName& value) noexcept; \ + QSet_##name qset_default_##name() noexcept; \ + void qset_drop_##name(QSet_##name& s) noexcept; \ + const typeName& qset_get_unchecked_##name(const QSet_##name& s, \ + ::std::size_t pos) noexcept; \ + void qset_insert_##name(QSet_##name& s, const typeName& value) noexcept; \ + std::size_t qset_len_##name(const QSet_##name& s) noexcept; \ + bool qset_remove_##name(QSet_##name& s, const typeName& value) noexcept; \ + } \ + } \ + } + +CXX_QT_QSET_METHODS(bool, bool); +CXX_QT_QSET_METHODS(float, f32); +CXX_QT_QSET_METHODS(double, f64); +CXX_QT_QSET_METHODS(::qint8, i8); +CXX_QT_QSET_METHODS(::qint16, i16); +CXX_QT_QSET_METHODS(::qint32, i32); +CXX_QT_QSET_METHODS(::QDate, QDate); +CXX_QT_QSET_METHODS(::QDateTime, QDateTime); +CXX_QT_QSET_METHODS(::QString, QString); +CXX_QT_QSET_METHODS(::QTime, QTime); +CXX_QT_QSET_METHODS(::QUrl, QUrl); +CXX_QT_QSET_METHODS(::quint8, u8); +CXX_QT_QSET_METHODS(::quint16, u16); +CXX_QT_QSET_METHODS(::quint32, u32); diff --git a/crates/cxx-qt-lib-headers/src/lib.rs b/crates/cxx-qt-lib-headers/src/lib.rs index 3a8eec299..f8bd2ce75 100644 --- a/crates/cxx-qt-lib-headers/src/lib.rs +++ b/crates/cxx-qt-lib-headers/src/lib.rs @@ -10,7 +10,7 @@ use std::{fs::File, io::Write, path::Path}; -static HEADERS: [(&str, &str); 15] = [ +static HEADERS: [(&str, &str); 16] = [ (include_str!("../include/convert.h"), "convert.h"), (include_str!("../include/cxxqt_thread.h"), "cxxqt_thread.h"), (include_str!("../include/qcolor.h"), "qcolor.h"), @@ -20,6 +20,7 @@ static HEADERS: [(&str, &str); 15] = [ (include_str!("../include/qpointf.h"), "qpointf.h"), (include_str!("../include/qrect.h"), "qrect.h"), (include_str!("../include/qrectf.h"), "qrectf.h"), + (include_str!("../include/qset.h"), "qset.h"), (include_str!("../include/qsize.h"), "qsize.h"), (include_str!("../include/qsizef.h"), "qsizef.h"), (include_str!("../include/qstring.h"), "qstring.h"), diff --git a/crates/cxx-qt-lib/build.rs b/crates/cxx-qt-lib/build.rs index a1151c462..d00daee39 100644 --- a/crates/cxx-qt-lib/build.rs +++ b/crates/cxx-qt-lib/build.rs @@ -18,7 +18,7 @@ fn main() { qtbuild.version().major ); - let bridges = [ + let rust_bridges = [ "qcolor", "qdate", "qdatetime", @@ -26,6 +26,20 @@ fn main() { "qpointf", "qrect", "qrectf", + "qset/qset_bool", + "qset/qset_f32", + "qset/qset_f64", + "qset/qset_i8", + "qset/qset_i16", + "qset/qset_i32", + "qset/qset_qdate", + "qset/qset_qdatetime", + "qset/qset_qstring", + "qset/qset_qtime", + "qset/qset_qurl", + "qset/qset_u8", + "qset/qset_u16", + "qset/qset_u32", "qsize", "qsizef", "qstring", @@ -33,7 +47,7 @@ fn main() { "qurl", "qvariant", ]; - for bridge in bridges { + for bridge in rust_bridges { println!("cargo:rerun-if-changed=src/types/{}.rs", bridge); } @@ -44,13 +58,30 @@ fn main() { } let mut builder = cxx_build::bridges( - bridges + rust_bridges .iter() .map(|bridge| format!("src/types/{}.rs", bridge)), ); - for bridge in bridges { - builder.file(format!("src/types/{}.cpp", bridge)); - println!("cargo:rerun-if-changed=src/types/{}.cpp", bridge); + + let cpp_files = [ + "qcolor", + "qdate", + "qdatetime", + "qpoint", + "qpointf", + "qrect", + "qrectf", + "qset/qset", + "qsize", + "qsizef", + "qstring", + "qtime", + "qurl", + "qvariant", + ]; + for cpp_file in cpp_files { + builder.file(format!("src/types/{}.cpp", cpp_file)); + println!("cargo:rerun-if-changed=src/types/{}.cpp", cpp_file); } builder.file("src/qt_types.cpp"); println!("cargo:rerun-if-changed=src/qt_types.cpp"); diff --git a/crates/cxx-qt-lib/src/types/mod.rs b/crates/cxx-qt-lib/src/types/mod.rs index a86119dc5..b6ab7f78b 100644 --- a/crates/cxx-qt-lib/src/types/mod.rs +++ b/crates/cxx-qt-lib/src/types/mod.rs @@ -18,6 +18,9 @@ pub use qrect::QRect; mod qrectf; pub use qrectf::QRectF; +mod qset; +pub use qset::{QSet, QSetElement}; + mod qsize; pub use qsize::QSize; diff --git a/crates/cxx-qt-lib/src/types/qset/generate.sh b/crates/cxx-qt-lib/src/types/qset/generate.sh new file mode 100755 index 000000000..4a55b8251 --- /dev/null +++ b/crates/cxx-qt-lib/src/types/qset/generate.sh @@ -0,0 +1,110 @@ +#!/usr/bin/env bash + +# SPDX-FileCopyrightText: 2022 Klarälvdalens Datakonsult AB, a KDAB Group company +# SPDX-FileContributor: Andrew Hayzen +# +# SPDX-License-Identifier: MIT OR Apache-2.0 + +set -e + +SCRIPT=$(realpath "$0") +SCRIPTPATH=$(dirname "$SCRIPT") + +function generate_bridge_primitive() { + tee "$SCRIPTPATH/qset_$1.rs" < +// SPDX-FileContributor: Andrew Hayzen +// +// SPDX-License-Identifier: MIT OR Apache-2.0 + +#[cxx::bridge] +pub mod ffi { + unsafe extern "C++" { + include!("cxx-qt-lib/qset.h"); + type QSet_$1 = crate::QSet<$1>; + } + + #[namespace = "rust::cxxqtlib1::qset_$1"] + unsafe extern "C++" { + #[rust_name = "clear"] + fn qset_clear_$1(_: &mut QSet_$1); + #[rust_name = "clone"] + fn qset_clone_$1(_: &QSet_$1) -> QSet_$1; + #[rust_name = "contains"] + fn qset_contains_$1(_: &QSet_$1, _: &$1) -> bool; + #[rust_name = "default"] + fn qset_default_$1() -> QSet_$1; + #[rust_name = "drop"] + fn qset_drop_$1(_: &mut QSet_$1); + #[rust_name = "get_unchecked"] + #[allow(clippy::needless_lifetimes)] + unsafe fn qset_get_unchecked_$1<'a>(set: &'a QSet_$1, pos: usize) -> &'a $1; + #[rust_name = "insert"] + fn qset_insert_$1(_: &mut QSet_$1, _: &$1); + #[rust_name = "len"] + fn qset_len_$1(_: &QSet_$1) -> usize; + #[rust_name = "remove"] + fn qset_remove_$1(_: &mut QSet_$1, _: &$1) -> bool; + } +} +EOF + rustfmt "$SCRIPTPATH/qset_$1.rs" +} + +function generate_bridge_qt() { + tee "$SCRIPTPATH/qset_$2.rs" < +// SPDX-FileContributor: Andrew Hayzen +// +// SPDX-License-Identifier: MIT OR Apache-2.0 + +#[cxx::bridge] +pub mod ffi { + unsafe extern "C++" { + include!("cxx-qt-lib/$2.h"); + type $1 = crate::$1; + + include!("cxx-qt-lib/qset.h"); + type QSet_$1 = crate::QSet<$1>; + } + + #[namespace = "rust::cxxqtlib1::qset_$1"] + unsafe extern "C++" { + #[rust_name = "clear"] + fn qset_clear_$1(_: &mut QSet_$1); + #[rust_name = "clone"] + fn qset_clone_$1(_: &QSet_$1) -> QSet_$1; + #[rust_name = "contains"] + fn qset_contains_$1(_: &QSet_$1, _: &$1) -> bool; + #[rust_name = "default"] + fn qset_default_$1() -> QSet_$1; + #[rust_name = "drop"] + fn qset_drop_$1(_: &mut QSet_$1); + #[rust_name = "get_unchecked"] + unsafe fn qset_get_unchecked_$1(set: &QSet_$1, pos: usize) -> &$1; + #[rust_name = "insert"] + fn qset_insert_$1(_: &mut QSet_$1, _: &$1); + #[rust_name = "len"] + fn qset_len_$1(_: &QSet_$1) -> usize; + #[rust_name = "remove"] + fn qset_remove_$1(_: &mut QSet_$1, _: &$1) -> bool; + } +} +EOF + rustfmt "$SCRIPTPATH/qset_$2.rs" +} + +generate_bridge_primitive "bool" +generate_bridge_primitive "f32" +generate_bridge_primitive "f64" +generate_bridge_primitive "i8" +generate_bridge_primitive "i16" +generate_bridge_primitive "i32" +generate_bridge_qt "QDate" "qdate" +generate_bridge_qt "QDateTime" "qdatetime" +generate_bridge_qt "QString" "qstring" +generate_bridge_qt "QTime" "qtime" +generate_bridge_qt "QUrl" "qurl" +generate_bridge_primitive "u8" +generate_bridge_primitive "u16" +generate_bridge_primitive "u32" diff --git a/crates/cxx-qt-lib/src/types/qset/mod.rs b/crates/cxx-qt-lib/src/types/qset/mod.rs new file mode 100644 index 000000000..89025e213 --- /dev/null +++ b/crates/cxx-qt-lib/src/types/qset/mod.rs @@ -0,0 +1,258 @@ +// SPDX-FileCopyrightText: 2022 Klarälvdalens Datakonsult AB, a KDAB Group company +// SPDX-FileContributor: Andrew Hayzen +// +// SPDX-License-Identifier: MIT OR Apache-2.0 +use crate::{QDate, QDateTime, QString, QTime, QUrl}; +use core::{marker::PhantomData, mem::MaybeUninit}; +use cxx::{type_id, ExternType}; + +mod qset_bool; +mod qset_f32; +mod qset_f64; +mod qset_i16; +mod qset_i32; +mod qset_i8; +mod qset_qdate; +mod qset_qdatetime; +mod qset_qstring; +mod qset_qtime; +mod qset_qurl; +mod qset_u16; +mod qset_u32; +mod qset_u8; + +/// The QSet class is a template class that provides a hash-table-based set. +/// +/// Note that this means that T needs to have a global `qHash()` function. +/// +/// To use QSet with a custom type, implement the [`QSetElement`] trait for T. +#[repr(C)] +pub struct QSet +where + T: QSetElement, +{ + _space: MaybeUninit, + _value: PhantomData, +} + +impl Clone for QSet +where + T: QSetElement, +{ + /// Constructs a copy of the QSet. + fn clone(&self) -> Self { + T::clone(self) + } +} + +impl Default for QSet +where + T: QSetElement, +{ + /// Constructs an empty set. + fn default() -> Self { + T::default() + } +} + +impl Drop for QSet +where + T: QSetElement, +{ + /// Destroys the QSet. + fn drop(&mut self) { + T::drop(self); + } +} + +impl QSet +where + T: QSetElement, +{ + /// Removes all elements from the set. + pub fn clear(&mut self) { + T::clear(self); + } + + /// Returns true if the set contains item value; otherwise returns false. + pub fn contains(&self, value: &T) -> bool { + T::contains(self, value) + } + + /// Inserts item value into the set, if value isn't already in the set, + /// and returns an iterator pointing at the inserted item. + /// + /// The value is a reference here so it can be opaque or trivial but + /// note that the value is copied when being inserted into the set. + pub fn insert_clone(&mut self, value: &T) { + T::insert_clone(self, value); + } + + /// Returns true if the set contains no elements; otherwise returns false. + pub fn is_empty(&self) -> bool { + T::len(self) == 0 + } + + /// An iterator visiting all elements in arbitrary order. + /// The iterator element type is &'a T. + pub fn iter(&self) -> Iter { + Iter { + set: self, + index: 0, + } + } + + /// Returns the number of items in the set. + pub fn len(&self) -> usize { + T::len(self) + } + + /// Removes any occurrence of item value from the set. + /// Returns true if an item was actually removed; otherwise returns false. + pub fn remove(&mut self, value: &T) -> bool { + T::remove(self, value) + } +} + +impl QSet +where + T: QSetElement + ExternType, +{ + /// Inserts item value into the set, if value isn't already in the set, + /// and returns an iterator pointing at the inserted item. + pub fn insert(&mut self, value: T) { + T::insert(self, value); + } +} + +unsafe impl ExternType for QSet +where + T: ExternType + QSetElement, +{ + type Id = T::TypeId; + type Kind = cxx::kind::Trivial; +} + +pub struct Iter<'a, T> +where + T: QSetElement, +{ + set: &'a QSet, + index: usize, +} + +impl<'a, T> Iterator for Iter<'a, T> +where + T: QSetElement, +{ + type Item = &'a T; + + fn next(&mut self) -> Option { + if self.index < self.set.len() { + let next = unsafe { T::get_unchecked(self.set, self.index) }; + self.index += 1; + Some(next) + } else { + None + } + } + + fn size_hint(&self) -> (usize, Option) { + let len = self.len(); + (len, Some(len)) + } +} + +impl<'a, T> ExactSizeIterator for Iter<'a, T> +where + T: QSetElement, +{ + fn len(&self) -> usize { + self.set.len() - self.index + } +} + +/// Trait implementation for an element in a [`QSet`]. +pub trait QSetElement: Sized { + type TypeId; + + fn clear(set: &mut QSet); + fn clone(set: &QSet) -> QSet; + fn contains(set: &QSet, value: &Self) -> bool; + fn default() -> QSet; + fn drop(set: &mut QSet); + /// # Safety + /// + /// Calling this method with an out-of-bounds index is undefined behavior + /// even if the resulting reference is not used. + unsafe fn get_unchecked(set: &QSet, pos: usize) -> &Self; + fn insert(set: &mut QSet, value: Self) + where + Self: ExternType; + fn insert_clone(set: &mut QSet, value: &Self); + fn len(set: &QSet) -> usize; + fn remove(set: &mut QSet, value: &Self) -> bool; +} + +macro_rules! impl_qset_element { + ( $typeName:ty, $module:ident, $typeId:literal ) => { + impl QSetElement for $typeName { + type TypeId = type_id!($typeId); + + fn clear(set: &mut QSet) { + $module::ffi::clear(set); + } + + fn clone(set: &QSet) -> QSet { + $module::ffi::clone(set) + } + + fn contains(set: &QSet, value: &Self) -> bool { + $module::ffi::contains(set, value) + } + + fn default() -> QSet { + $module::ffi::default() + } + + fn drop(set: &mut QSet) { + $module::ffi::drop(set); + } + + unsafe fn get_unchecked(set: &QSet, pos: usize) -> &Self { + $module::ffi::get_unchecked(set, pos) + } + + fn insert(set: &mut QSet, value: Self) { + $module::ffi::insert(set, &value); + } + + fn insert_clone(set: &mut QSet, value: &Self) { + $module::ffi::insert(set, value); + } + + fn len(set: &QSet) -> usize { + $module::ffi::len(set) + } + + fn remove(set: &mut QSet, value: &Self) -> bool { + $module::ffi::remove(set, value) + } + } + }; +} + +impl_qset_element!(bool, qset_bool, "QSet_bool"); +impl_qset_element!(f32, qset_f32, "QSet_f32"); +impl_qset_element!(f64, qset_f64, "QSet_f64"); +impl_qset_element!(i8, qset_i8, "QSet_i8"); +impl_qset_element!(i16, qset_i16, "QSet_i16"); +impl_qset_element!(i32, qset_i32, "QSet_i32"); +impl_qset_element!(QDate, qset_qdate, "QSet_QDate"); +impl_qset_element!(QDateTime, qset_qdatetime, "QSet_QDateTime"); +impl_qset_element!(QString, qset_qstring, "QSet_QString"); +impl_qset_element!(QTime, qset_qtime, "QSet_QTime"); +impl_qset_element!(QUrl, qset_qurl, "QSet_QUrl"); +impl_qset_element!(u8, qset_u8, "QSet_u8"); +impl_qset_element!(u16, qset_u16, "QSet_u16"); +impl_qset_element!(u32, qset_u32, "QSet_u32"); diff --git a/crates/cxx-qt-lib/src/types/qset/qset.cpp b/crates/cxx-qt-lib/src/types/qset/qset.cpp new file mode 100644 index 000000000..8accf00d3 --- /dev/null +++ b/crates/cxx-qt-lib/src/types/qset/qset.cpp @@ -0,0 +1,97 @@ +// clang-format off +// SPDX-FileCopyrightText: 2022 Klarälvdalens Datakonsult AB, a KDAB Group company +// clang-format on +// SPDX-FileContributor: Andrew Hayzen +// +// SPDX-License-Identifier: MIT OR Apache-2.0 +#include "cxx-qt-lib/qset.h" + +#include "../assertion_utils.h" + +#define CXX_QT_QSET_ASSERTS(typeName, name) \ + assert_alignment_and_size( \ + QSet_##name, alignof(std::size_t), sizeof(std::size_t)); \ + \ + static_assert(!std::is_trivially_copy_assignable::value); \ + static_assert(!std::is_trivially_copy_constructible::value); \ + static_assert(!std::is_trivially_destructible::value); \ + \ + static_assert(QTypeInfo::isRelocatable); \ + \ + static_assert(std::is_copy_assignable::value); \ + static_assert(std::is_copy_constructible::value); + +#define CXX_QT_QSET_METHODS_IMPL(typeName, name) \ + CXX_QT_QSET_ASSERTS(typeName, name); \ + \ + namespace rust { \ + namespace cxxqtlib1 { \ + namespace qset_##name \ + { \ + void qset_clear_##name(QSet_##name& s) noexcept \ + { \ + s.clear(); \ + } \ + \ + QSet_##name qset_clone_##name(const QSet_##name& s) noexcept \ + { \ + return QSet(s); \ + } \ + \ + bool qset_contains_##name(const QSet_##name& s, \ + const typeName& value) noexcept \ + { \ + return s.contains(value); \ + } \ + \ + QSet_##name qset_default_##name() noexcept \ + { \ + return QSet_##name(); \ + } \ + \ + void qset_drop_##name(QSet_##name& s) noexcept \ + { \ + s.~QSet_##name(); \ + } \ + \ + const typeName& qset_get_unchecked_##name(const QSet_##name& s, \ + ::std::size_t pos) noexcept \ + { \ + Q_ASSERT(pos < static_cast<::std::size_t>(s.size())); \ + auto it = s.cbegin(); \ + std::advance(it, pos); \ + return *it; \ + } \ + \ + void qset_insert_##name(QSet_##name& s, const typeName& value) noexcept \ + { \ + s.insert(value); \ + } \ + \ + ::std::size_t qset_len_##name(const QSet_##name& s) noexcept \ + { \ + return static_cast<::std::size_t>(s.size()); \ + } \ + \ + bool qset_remove_##name(QSet_##name& s, const typeName& value) noexcept \ + { \ + return s.remove(value); \ + } \ + } \ + } \ + } + +CXX_QT_QSET_METHODS_IMPL(bool, bool); +CXX_QT_QSET_METHODS_IMPL(float, f32); +CXX_QT_QSET_METHODS_IMPL(double, f64); +CXX_QT_QSET_METHODS_IMPL(::qint8, i8); +CXX_QT_QSET_METHODS_IMPL(::qint16, i16); +CXX_QT_QSET_METHODS_IMPL(::qint32, i32); +CXX_QT_QSET_METHODS_IMPL(::QDate, QDate); +CXX_QT_QSET_METHODS_IMPL(::QDateTime, QDateTime); +CXX_QT_QSET_METHODS_IMPL(::QString, QString); +CXX_QT_QSET_METHODS_IMPL(::QTime, QTime); +CXX_QT_QSET_METHODS_IMPL(::QUrl, QUrl); +CXX_QT_QSET_METHODS_IMPL(::quint8, u8); +CXX_QT_QSET_METHODS_IMPL(::quint16, u16); +CXX_QT_QSET_METHODS_IMPL(::quint32, u32); diff --git a/crates/cxx-qt-lib/src/types/qset/qset_bool.rs b/crates/cxx-qt-lib/src/types/qset/qset_bool.rs new file mode 100644 index 000000000..430653aeb --- /dev/null +++ b/crates/cxx-qt-lib/src/types/qset/qset_bool.rs @@ -0,0 +1,35 @@ +// SPDX-FileCopyrightText: 2022 Klarälvdalens Datakonsult AB, a KDAB Group company +// SPDX-FileContributor: Andrew Hayzen +// +// SPDX-License-Identifier: MIT OR Apache-2.0 + +#[cxx::bridge] +pub mod ffi { + unsafe extern "C++" { + include!("cxx-qt-lib/qset.h"); + type QSet_bool = crate::QSet; + } + + #[namespace = "rust::cxxqtlib1::qset_bool"] + unsafe extern "C++" { + #[rust_name = "clear"] + fn qset_clear_bool(_: &mut QSet_bool); + #[rust_name = "clone"] + fn qset_clone_bool(_: &QSet_bool) -> QSet_bool; + #[rust_name = "contains"] + fn qset_contains_bool(_: &QSet_bool, _: &bool) -> bool; + #[rust_name = "default"] + fn qset_default_bool() -> QSet_bool; + #[rust_name = "drop"] + fn qset_drop_bool(_: &mut QSet_bool); + #[rust_name = "get_unchecked"] + #[allow(clippy::needless_lifetimes)] + unsafe fn qset_get_unchecked_bool<'a>(set: &'a QSet_bool, pos: usize) -> &'a bool; + #[rust_name = "insert"] + fn qset_insert_bool(_: &mut QSet_bool, _: &bool); + #[rust_name = "len"] + fn qset_len_bool(_: &QSet_bool) -> usize; + #[rust_name = "remove"] + fn qset_remove_bool(_: &mut QSet_bool, _: &bool) -> bool; + } +} diff --git a/crates/cxx-qt-lib/src/types/qset/qset_f32.rs b/crates/cxx-qt-lib/src/types/qset/qset_f32.rs new file mode 100644 index 000000000..c20bcffb4 --- /dev/null +++ b/crates/cxx-qt-lib/src/types/qset/qset_f32.rs @@ -0,0 +1,35 @@ +// SPDX-FileCopyrightText: 2022 Klarälvdalens Datakonsult AB, a KDAB Group company +// SPDX-FileContributor: Andrew Hayzen +// +// SPDX-License-Identifier: MIT OR Apache-2.0 + +#[cxx::bridge] +pub mod ffi { + unsafe extern "C++" { + include!("cxx-qt-lib/qset.h"); + type QSet_f32 = crate::QSet; + } + + #[namespace = "rust::cxxqtlib1::qset_f32"] + unsafe extern "C++" { + #[rust_name = "clear"] + fn qset_clear_f32(_: &mut QSet_f32); + #[rust_name = "clone"] + fn qset_clone_f32(_: &QSet_f32) -> QSet_f32; + #[rust_name = "contains"] + fn qset_contains_f32(_: &QSet_f32, _: &f32) -> bool; + #[rust_name = "default"] + fn qset_default_f32() -> QSet_f32; + #[rust_name = "drop"] + fn qset_drop_f32(_: &mut QSet_f32); + #[rust_name = "get_unchecked"] + #[allow(clippy::needless_lifetimes)] + unsafe fn qset_get_unchecked_f32<'a>(set: &'a QSet_f32, pos: usize) -> &'a f32; + #[rust_name = "insert"] + fn qset_insert_f32(_: &mut QSet_f32, _: &f32); + #[rust_name = "len"] + fn qset_len_f32(_: &QSet_f32) -> usize; + #[rust_name = "remove"] + fn qset_remove_f32(_: &mut QSet_f32, _: &f32) -> bool; + } +} diff --git a/crates/cxx-qt-lib/src/types/qset/qset_f64.rs b/crates/cxx-qt-lib/src/types/qset/qset_f64.rs new file mode 100644 index 000000000..d2cb7e6b3 --- /dev/null +++ b/crates/cxx-qt-lib/src/types/qset/qset_f64.rs @@ -0,0 +1,35 @@ +// SPDX-FileCopyrightText: 2022 Klarälvdalens Datakonsult AB, a KDAB Group company +// SPDX-FileContributor: Andrew Hayzen +// +// SPDX-License-Identifier: MIT OR Apache-2.0 + +#[cxx::bridge] +pub mod ffi { + unsafe extern "C++" { + include!("cxx-qt-lib/qset.h"); + type QSet_f64 = crate::QSet; + } + + #[namespace = "rust::cxxqtlib1::qset_f64"] + unsafe extern "C++" { + #[rust_name = "clear"] + fn qset_clear_f64(_: &mut QSet_f64); + #[rust_name = "clone"] + fn qset_clone_f64(_: &QSet_f64) -> QSet_f64; + #[rust_name = "contains"] + fn qset_contains_f64(_: &QSet_f64, _: &f64) -> bool; + #[rust_name = "default"] + fn qset_default_f64() -> QSet_f64; + #[rust_name = "drop"] + fn qset_drop_f64(_: &mut QSet_f64); + #[rust_name = "get_unchecked"] + #[allow(clippy::needless_lifetimes)] + unsafe fn qset_get_unchecked_f64<'a>(set: &'a QSet_f64, pos: usize) -> &'a f64; + #[rust_name = "insert"] + fn qset_insert_f64(_: &mut QSet_f64, _: &f64); + #[rust_name = "len"] + fn qset_len_f64(_: &QSet_f64) -> usize; + #[rust_name = "remove"] + fn qset_remove_f64(_: &mut QSet_f64, _: &f64) -> bool; + } +} diff --git a/crates/cxx-qt-lib/src/types/qset/qset_i16.rs b/crates/cxx-qt-lib/src/types/qset/qset_i16.rs new file mode 100644 index 000000000..6664919f5 --- /dev/null +++ b/crates/cxx-qt-lib/src/types/qset/qset_i16.rs @@ -0,0 +1,35 @@ +// SPDX-FileCopyrightText: 2022 Klarälvdalens Datakonsult AB, a KDAB Group company +// SPDX-FileContributor: Andrew Hayzen +// +// SPDX-License-Identifier: MIT OR Apache-2.0 + +#[cxx::bridge] +pub mod ffi { + unsafe extern "C++" { + include!("cxx-qt-lib/qset.h"); + type QSet_i16 = crate::QSet; + } + + #[namespace = "rust::cxxqtlib1::qset_i16"] + unsafe extern "C++" { + #[rust_name = "clear"] + fn qset_clear_i16(_: &mut QSet_i16); + #[rust_name = "clone"] + fn qset_clone_i16(_: &QSet_i16) -> QSet_i16; + #[rust_name = "contains"] + fn qset_contains_i16(_: &QSet_i16, _: &i16) -> bool; + #[rust_name = "default"] + fn qset_default_i16() -> QSet_i16; + #[rust_name = "drop"] + fn qset_drop_i16(_: &mut QSet_i16); + #[rust_name = "get_unchecked"] + #[allow(clippy::needless_lifetimes)] + unsafe fn qset_get_unchecked_i16<'a>(set: &'a QSet_i16, pos: usize) -> &'a i16; + #[rust_name = "insert"] + fn qset_insert_i16(_: &mut QSet_i16, _: &i16); + #[rust_name = "len"] + fn qset_len_i16(_: &QSet_i16) -> usize; + #[rust_name = "remove"] + fn qset_remove_i16(_: &mut QSet_i16, _: &i16) -> bool; + } +} diff --git a/crates/cxx-qt-lib/src/types/qset/qset_i32.rs b/crates/cxx-qt-lib/src/types/qset/qset_i32.rs new file mode 100644 index 000000000..dfc4fa791 --- /dev/null +++ b/crates/cxx-qt-lib/src/types/qset/qset_i32.rs @@ -0,0 +1,35 @@ +// SPDX-FileCopyrightText: 2022 Klarälvdalens Datakonsult AB, a KDAB Group company +// SPDX-FileContributor: Andrew Hayzen +// +// SPDX-License-Identifier: MIT OR Apache-2.0 + +#[cxx::bridge] +pub mod ffi { + unsafe extern "C++" { + include!("cxx-qt-lib/qset.h"); + type QSet_i32 = crate::QSet; + } + + #[namespace = "rust::cxxqtlib1::qset_i32"] + unsafe extern "C++" { + #[rust_name = "clear"] + fn qset_clear_i32(_: &mut QSet_i32); + #[rust_name = "clone"] + fn qset_clone_i32(_: &QSet_i32) -> QSet_i32; + #[rust_name = "contains"] + fn qset_contains_i32(_: &QSet_i32, _: &i32) -> bool; + #[rust_name = "default"] + fn qset_default_i32() -> QSet_i32; + #[rust_name = "drop"] + fn qset_drop_i32(_: &mut QSet_i32); + #[rust_name = "get_unchecked"] + #[allow(clippy::needless_lifetimes)] + unsafe fn qset_get_unchecked_i32<'a>(set: &'a QSet_i32, pos: usize) -> &'a i32; + #[rust_name = "insert"] + fn qset_insert_i32(_: &mut QSet_i32, _: &i32); + #[rust_name = "len"] + fn qset_len_i32(_: &QSet_i32) -> usize; + #[rust_name = "remove"] + fn qset_remove_i32(_: &mut QSet_i32, _: &i32) -> bool; + } +} diff --git a/crates/cxx-qt-lib/src/types/qset/qset_i8.rs b/crates/cxx-qt-lib/src/types/qset/qset_i8.rs new file mode 100644 index 000000000..5d038e233 --- /dev/null +++ b/crates/cxx-qt-lib/src/types/qset/qset_i8.rs @@ -0,0 +1,35 @@ +// SPDX-FileCopyrightText: 2022 Klarälvdalens Datakonsult AB, a KDAB Group company +// SPDX-FileContributor: Andrew Hayzen +// +// SPDX-License-Identifier: MIT OR Apache-2.0 + +#[cxx::bridge] +pub mod ffi { + unsafe extern "C++" { + include!("cxx-qt-lib/qset.h"); + type QSet_i8 = crate::QSet; + } + + #[namespace = "rust::cxxqtlib1::qset_i8"] + unsafe extern "C++" { + #[rust_name = "clear"] + fn qset_clear_i8(_: &mut QSet_i8); + #[rust_name = "clone"] + fn qset_clone_i8(_: &QSet_i8) -> QSet_i8; + #[rust_name = "contains"] + fn qset_contains_i8(_: &QSet_i8, _: &i8) -> bool; + #[rust_name = "default"] + fn qset_default_i8() -> QSet_i8; + #[rust_name = "drop"] + fn qset_drop_i8(_: &mut QSet_i8); + #[rust_name = "get_unchecked"] + #[allow(clippy::needless_lifetimes)] + unsafe fn qset_get_unchecked_i8<'a>(set: &'a QSet_i8, pos: usize) -> &'a i8; + #[rust_name = "insert"] + fn qset_insert_i8(_: &mut QSet_i8, _: &i8); + #[rust_name = "len"] + fn qset_len_i8(_: &QSet_i8) -> usize; + #[rust_name = "remove"] + fn qset_remove_i8(_: &mut QSet_i8, _: &i8) -> bool; + } +} diff --git a/crates/cxx-qt-lib/src/types/qset/qset_qdate.rs b/crates/cxx-qt-lib/src/types/qset/qset_qdate.rs new file mode 100644 index 000000000..530546ac7 --- /dev/null +++ b/crates/cxx-qt-lib/src/types/qset/qset_qdate.rs @@ -0,0 +1,37 @@ +// SPDX-FileCopyrightText: 2022 Klarälvdalens Datakonsult AB, a KDAB Group company +// SPDX-FileContributor: Andrew Hayzen +// +// SPDX-License-Identifier: MIT OR Apache-2.0 + +#[cxx::bridge] +pub mod ffi { + unsafe extern "C++" { + include!("cxx-qt-lib/qdate.h"); + type QDate = crate::QDate; + + include!("cxx-qt-lib/qset.h"); + type QSet_QDate = crate::QSet; + } + + #[namespace = "rust::cxxqtlib1::qset_QDate"] + unsafe extern "C++" { + #[rust_name = "clear"] + fn qset_clear_QDate(_: &mut QSet_QDate); + #[rust_name = "clone"] + fn qset_clone_QDate(_: &QSet_QDate) -> QSet_QDate; + #[rust_name = "contains"] + fn qset_contains_QDate(_: &QSet_QDate, _: &QDate) -> bool; + #[rust_name = "default"] + fn qset_default_QDate() -> QSet_QDate; + #[rust_name = "drop"] + fn qset_drop_QDate(_: &mut QSet_QDate); + #[rust_name = "get_unchecked"] + unsafe fn qset_get_unchecked_QDate(set: &QSet_QDate, pos: usize) -> &QDate; + #[rust_name = "insert"] + fn qset_insert_QDate(_: &mut QSet_QDate, _: &QDate); + #[rust_name = "len"] + fn qset_len_QDate(_: &QSet_QDate) -> usize; + #[rust_name = "remove"] + fn qset_remove_QDate(_: &mut QSet_QDate, _: &QDate) -> bool; + } +} diff --git a/crates/cxx-qt-lib/src/types/qset/qset_qdatetime.rs b/crates/cxx-qt-lib/src/types/qset/qset_qdatetime.rs new file mode 100644 index 000000000..bf1371c2f --- /dev/null +++ b/crates/cxx-qt-lib/src/types/qset/qset_qdatetime.rs @@ -0,0 +1,37 @@ +// SPDX-FileCopyrightText: 2022 Klarälvdalens Datakonsult AB, a KDAB Group company +// SPDX-FileContributor: Andrew Hayzen +// +// SPDX-License-Identifier: MIT OR Apache-2.0 + +#[cxx::bridge] +pub mod ffi { + unsafe extern "C++" { + include!("cxx-qt-lib/qdatetime.h"); + type QDateTime = crate::QDateTime; + + include!("cxx-qt-lib/qset.h"); + type QSet_QDateTime = crate::QSet; + } + + #[namespace = "rust::cxxqtlib1::qset_QDateTime"] + unsafe extern "C++" { + #[rust_name = "clear"] + fn qset_clear_QDateTime(_: &mut QSet_QDateTime); + #[rust_name = "clone"] + fn qset_clone_QDateTime(_: &QSet_QDateTime) -> QSet_QDateTime; + #[rust_name = "contains"] + fn qset_contains_QDateTime(_: &QSet_QDateTime, _: &QDateTime) -> bool; + #[rust_name = "default"] + fn qset_default_QDateTime() -> QSet_QDateTime; + #[rust_name = "drop"] + fn qset_drop_QDateTime(_: &mut QSet_QDateTime); + #[rust_name = "get_unchecked"] + unsafe fn qset_get_unchecked_QDateTime(set: &QSet_QDateTime, pos: usize) -> &QDateTime; + #[rust_name = "insert"] + fn qset_insert_QDateTime(_: &mut QSet_QDateTime, _: &QDateTime); + #[rust_name = "len"] + fn qset_len_QDateTime(_: &QSet_QDateTime) -> usize; + #[rust_name = "remove"] + fn qset_remove_QDateTime(_: &mut QSet_QDateTime, _: &QDateTime) -> bool; + } +} diff --git a/crates/cxx-qt-lib/src/types/qset/qset_qstring.rs b/crates/cxx-qt-lib/src/types/qset/qset_qstring.rs new file mode 100644 index 000000000..e6031e176 --- /dev/null +++ b/crates/cxx-qt-lib/src/types/qset/qset_qstring.rs @@ -0,0 +1,37 @@ +// SPDX-FileCopyrightText: 2022 Klarälvdalens Datakonsult AB, a KDAB Group company +// SPDX-FileContributor: Andrew Hayzen +// +// SPDX-License-Identifier: MIT OR Apache-2.0 + +#[cxx::bridge] +pub mod ffi { + unsafe extern "C++" { + include!("cxx-qt-lib/qstring.h"); + type QString = crate::QString; + + include!("cxx-qt-lib/qset.h"); + type QSet_QString = crate::QSet; + } + + #[namespace = "rust::cxxqtlib1::qset_QString"] + unsafe extern "C++" { + #[rust_name = "clear"] + fn qset_clear_QString(_: &mut QSet_QString); + #[rust_name = "clone"] + fn qset_clone_QString(_: &QSet_QString) -> QSet_QString; + #[rust_name = "contains"] + fn qset_contains_QString(_: &QSet_QString, _: &QString) -> bool; + #[rust_name = "default"] + fn qset_default_QString() -> QSet_QString; + #[rust_name = "drop"] + fn qset_drop_QString(_: &mut QSet_QString); + #[rust_name = "get_unchecked"] + unsafe fn qset_get_unchecked_QString(set: &QSet_QString, pos: usize) -> &QString; + #[rust_name = "insert"] + fn qset_insert_QString(_: &mut QSet_QString, _: &QString); + #[rust_name = "len"] + fn qset_len_QString(_: &QSet_QString) -> usize; + #[rust_name = "remove"] + fn qset_remove_QString(_: &mut QSet_QString, _: &QString) -> bool; + } +} diff --git a/crates/cxx-qt-lib/src/types/qset/qset_qtime.rs b/crates/cxx-qt-lib/src/types/qset/qset_qtime.rs new file mode 100644 index 000000000..4116ed1fe --- /dev/null +++ b/crates/cxx-qt-lib/src/types/qset/qset_qtime.rs @@ -0,0 +1,37 @@ +// SPDX-FileCopyrightText: 2022 Klarälvdalens Datakonsult AB, a KDAB Group company +// SPDX-FileContributor: Andrew Hayzen +// +// SPDX-License-Identifier: MIT OR Apache-2.0 + +#[cxx::bridge] +pub mod ffi { + unsafe extern "C++" { + include!("cxx-qt-lib/qtime.h"); + type QTime = crate::QTime; + + include!("cxx-qt-lib/qset.h"); + type QSet_QTime = crate::QSet; + } + + #[namespace = "rust::cxxqtlib1::qset_QTime"] + unsafe extern "C++" { + #[rust_name = "clear"] + fn qset_clear_QTime(_: &mut QSet_QTime); + #[rust_name = "clone"] + fn qset_clone_QTime(_: &QSet_QTime) -> QSet_QTime; + #[rust_name = "contains"] + fn qset_contains_QTime(_: &QSet_QTime, _: &QTime) -> bool; + #[rust_name = "default"] + fn qset_default_QTime() -> QSet_QTime; + #[rust_name = "drop"] + fn qset_drop_QTime(_: &mut QSet_QTime); + #[rust_name = "get_unchecked"] + unsafe fn qset_get_unchecked_QTime(set: &QSet_QTime, pos: usize) -> &QTime; + #[rust_name = "insert"] + fn qset_insert_QTime(_: &mut QSet_QTime, _: &QTime); + #[rust_name = "len"] + fn qset_len_QTime(_: &QSet_QTime) -> usize; + #[rust_name = "remove"] + fn qset_remove_QTime(_: &mut QSet_QTime, _: &QTime) -> bool; + } +} diff --git a/crates/cxx-qt-lib/src/types/qset/qset_qurl.rs b/crates/cxx-qt-lib/src/types/qset/qset_qurl.rs new file mode 100644 index 000000000..cb0675665 --- /dev/null +++ b/crates/cxx-qt-lib/src/types/qset/qset_qurl.rs @@ -0,0 +1,37 @@ +// SPDX-FileCopyrightText: 2022 Klarälvdalens Datakonsult AB, a KDAB Group company +// SPDX-FileContributor: Andrew Hayzen +// +// SPDX-License-Identifier: MIT OR Apache-2.0 + +#[cxx::bridge] +pub mod ffi { + unsafe extern "C++" { + include!("cxx-qt-lib/qurl.h"); + type QUrl = crate::QUrl; + + include!("cxx-qt-lib/qset.h"); + type QSet_QUrl = crate::QSet; + } + + #[namespace = "rust::cxxqtlib1::qset_QUrl"] + unsafe extern "C++" { + #[rust_name = "clear"] + fn qset_clear_QUrl(_: &mut QSet_QUrl); + #[rust_name = "clone"] + fn qset_clone_QUrl(_: &QSet_QUrl) -> QSet_QUrl; + #[rust_name = "contains"] + fn qset_contains_QUrl(_: &QSet_QUrl, _: &QUrl) -> bool; + #[rust_name = "default"] + fn qset_default_QUrl() -> QSet_QUrl; + #[rust_name = "drop"] + fn qset_drop_QUrl(_: &mut QSet_QUrl); + #[rust_name = "get_unchecked"] + unsafe fn qset_get_unchecked_QUrl(set: &QSet_QUrl, pos: usize) -> &QUrl; + #[rust_name = "insert"] + fn qset_insert_QUrl(_: &mut QSet_QUrl, _: &QUrl); + #[rust_name = "len"] + fn qset_len_QUrl(_: &QSet_QUrl) -> usize; + #[rust_name = "remove"] + fn qset_remove_QUrl(_: &mut QSet_QUrl, _: &QUrl) -> bool; + } +} diff --git a/crates/cxx-qt-lib/src/types/qset/qset_u16.rs b/crates/cxx-qt-lib/src/types/qset/qset_u16.rs new file mode 100644 index 000000000..6c62895a1 --- /dev/null +++ b/crates/cxx-qt-lib/src/types/qset/qset_u16.rs @@ -0,0 +1,35 @@ +// SPDX-FileCopyrightText: 2022 Klarälvdalens Datakonsult AB, a KDAB Group company +// SPDX-FileContributor: Andrew Hayzen +// +// SPDX-License-Identifier: MIT OR Apache-2.0 + +#[cxx::bridge] +pub mod ffi { + unsafe extern "C++" { + include!("cxx-qt-lib/qset.h"); + type QSet_u16 = crate::QSet; + } + + #[namespace = "rust::cxxqtlib1::qset_u16"] + unsafe extern "C++" { + #[rust_name = "clear"] + fn qset_clear_u16(_: &mut QSet_u16); + #[rust_name = "clone"] + fn qset_clone_u16(_: &QSet_u16) -> QSet_u16; + #[rust_name = "contains"] + fn qset_contains_u16(_: &QSet_u16, _: &u16) -> bool; + #[rust_name = "default"] + fn qset_default_u16() -> QSet_u16; + #[rust_name = "drop"] + fn qset_drop_u16(_: &mut QSet_u16); + #[rust_name = "get_unchecked"] + #[allow(clippy::needless_lifetimes)] + unsafe fn qset_get_unchecked_u16<'a>(set: &'a QSet_u16, pos: usize) -> &'a u16; + #[rust_name = "insert"] + fn qset_insert_u16(_: &mut QSet_u16, _: &u16); + #[rust_name = "len"] + fn qset_len_u16(_: &QSet_u16) -> usize; + #[rust_name = "remove"] + fn qset_remove_u16(_: &mut QSet_u16, _: &u16) -> bool; + } +} diff --git a/crates/cxx-qt-lib/src/types/qset/qset_u32.rs b/crates/cxx-qt-lib/src/types/qset/qset_u32.rs new file mode 100644 index 000000000..847f05f45 --- /dev/null +++ b/crates/cxx-qt-lib/src/types/qset/qset_u32.rs @@ -0,0 +1,35 @@ +// SPDX-FileCopyrightText: 2022 Klarälvdalens Datakonsult AB, a KDAB Group company +// SPDX-FileContributor: Andrew Hayzen +// +// SPDX-License-Identifier: MIT OR Apache-2.0 + +#[cxx::bridge] +pub mod ffi { + unsafe extern "C++" { + include!("cxx-qt-lib/qset.h"); + type QSet_u32 = crate::QSet; + } + + #[namespace = "rust::cxxqtlib1::qset_u32"] + unsafe extern "C++" { + #[rust_name = "clear"] + fn qset_clear_u32(_: &mut QSet_u32); + #[rust_name = "clone"] + fn qset_clone_u32(_: &QSet_u32) -> QSet_u32; + #[rust_name = "contains"] + fn qset_contains_u32(_: &QSet_u32, _: &u32) -> bool; + #[rust_name = "default"] + fn qset_default_u32() -> QSet_u32; + #[rust_name = "drop"] + fn qset_drop_u32(_: &mut QSet_u32); + #[rust_name = "get_unchecked"] + #[allow(clippy::needless_lifetimes)] + unsafe fn qset_get_unchecked_u32<'a>(set: &'a QSet_u32, pos: usize) -> &'a u32; + #[rust_name = "insert"] + fn qset_insert_u32(_: &mut QSet_u32, _: &u32); + #[rust_name = "len"] + fn qset_len_u32(_: &QSet_u32) -> usize; + #[rust_name = "remove"] + fn qset_remove_u32(_: &mut QSet_u32, _: &u32) -> bool; + } +} diff --git a/crates/cxx-qt-lib/src/types/qset/qset_u8.rs b/crates/cxx-qt-lib/src/types/qset/qset_u8.rs new file mode 100644 index 000000000..c2b32d8ca --- /dev/null +++ b/crates/cxx-qt-lib/src/types/qset/qset_u8.rs @@ -0,0 +1,35 @@ +// SPDX-FileCopyrightText: 2022 Klarälvdalens Datakonsult AB, a KDAB Group company +// SPDX-FileContributor: Andrew Hayzen +// +// SPDX-License-Identifier: MIT OR Apache-2.0 + +#[cxx::bridge] +pub mod ffi { + unsafe extern "C++" { + include!("cxx-qt-lib/qset.h"); + type QSet_u8 = crate::QSet; + } + + #[namespace = "rust::cxxqtlib1::qset_u8"] + unsafe extern "C++" { + #[rust_name = "clear"] + fn qset_clear_u8(_: &mut QSet_u8); + #[rust_name = "clone"] + fn qset_clone_u8(_: &QSet_u8) -> QSet_u8; + #[rust_name = "contains"] + fn qset_contains_u8(_: &QSet_u8, _: &u8) -> bool; + #[rust_name = "default"] + fn qset_default_u8() -> QSet_u8; + #[rust_name = "drop"] + fn qset_drop_u8(_: &mut QSet_u8); + #[rust_name = "get_unchecked"] + #[allow(clippy::needless_lifetimes)] + unsafe fn qset_get_unchecked_u8<'a>(set: &'a QSet_u8, pos: usize) -> &'a u8; + #[rust_name = "insert"] + fn qset_insert_u8(_: &mut QSet_u8, _: &u8); + #[rust_name = "len"] + fn qset_len_u8(_: &QSet_u8) -> usize; + #[rust_name = "remove"] + fn qset_remove_u8(_: &mut QSet_u8, _: &u8) -> bool; + } +} diff --git a/tests/qt_types_standalone/CMakeLists.txt b/tests/qt_types_standalone/CMakeLists.txt index 0fbfe6aef..21715b286 100644 --- a/tests/qt_types_standalone/CMakeLists.txt +++ b/tests/qt_types_standalone/CMakeLists.txt @@ -48,6 +48,7 @@ add_executable(${APP_NAME} cpp/qpointf.h cpp/qrect.h cpp/qrectf.h + cpp/qset.h cpp/qsize.h cpp/qsizef.h cpp/qstring.h diff --git a/tests/qt_types_standalone/cpp/main.cpp b/tests/qt_types_standalone/cpp/main.cpp index 81c69bf83..2759c55fe 100644 --- a/tests/qt_types_standalone/cpp/main.cpp +++ b/tests/qt_types_standalone/cpp/main.cpp @@ -15,6 +15,7 @@ #include "qpointf.h" #include "qrect.h" #include "qrectf.h" +#include "qset.h" #include "qsize.h" #include "qsizef.h" #include "qstring.h" @@ -42,6 +43,7 @@ main(int argc, char* argv[]) runTest(QScopedPointer(new QPointFTest)); runTest(QScopedPointer(new QRectTest)); runTest(QScopedPointer(new QRectFTest)); + runTest(QScopedPointer(new QSetTest)); runTest(QScopedPointer(new QSizeTest)); runTest(QScopedPointer(new QSizeFTest)); runTest(QScopedPointer(new QStringTest)); diff --git a/tests/qt_types_standalone/cpp/qset.h b/tests/qt_types_standalone/cpp/qset.h new file mode 100644 index 000000000..2e3889c74 --- /dev/null +++ b/tests/qt_types_standalone/cpp/qset.h @@ -0,0 +1,51 @@ +// clang-format off +// SPDX-FileCopyrightText: 2022 Klarälvdalens Datakonsult AB, a KDAB Group company +// clang-format on +// SPDX-FileContributor: Andrew Hayzen +// +// SPDX-License-Identifier: MIT OR Apache-2.0 +#pragma once + +#include +#include + +#include "cxx-qt-gen/qset_cxx.cxx.h" + +class QSetTest : public QObject +{ + Q_OBJECT + +private Q_SLOTS: + void construct() + { + const auto s = construct_qset_i32(); + QVERIFY(s.contains(1)); + QVERIFY(!s.contains(2)); + QVERIFY(s.contains(3)); + QCOMPARE(s.size(), 2); + } + + void read() + { + auto s = QSet<::std::int32_t>(); + s.insert(1); + s.insert(1); + s.insert(3); + s.insert(3); + QVERIFY(read_qset_i32(s)); + } + + void clone() + { + auto s = QSet<::std::int32_t>(); + s.insert(1); + s.insert(1); + s.insert(3); + s.insert(3); + const auto c = clone_qset_i32(s); + QVERIFY(c.contains(1)); + QVERIFY(!c.contains(2)); + QVERIFY(c.contains(3)); + QCOMPARE(c.size(), 2); + } +}; diff --git a/tests/qt_types_standalone/rust/build.rs b/tests/qt_types_standalone/rust/build.rs index 87f05341b..2d6b7e564 100644 --- a/tests/qt_types_standalone/rust/build.rs +++ b/tests/qt_types_standalone/rust/build.rs @@ -14,6 +14,7 @@ fn main() { .file("src/qpointf.rs") .file("src/qrect.rs") .file("src/qrectf.rs") + .file("src/qset.rs") .file("src/qsize.rs") .file("src/qsizef.rs") .file("src/qstring.rs") diff --git a/tests/qt_types_standalone/rust/src/lib.rs b/tests/qt_types_standalone/rust/src/lib.rs index 4466fd01f..50f9a0ad1 100644 --- a/tests/qt_types_standalone/rust/src/lib.rs +++ b/tests/qt_types_standalone/rust/src/lib.rs @@ -11,6 +11,7 @@ mod qpoint; mod qpointf; mod qrect; mod qrectf; +mod qset; mod qsize; mod qsizef; mod qstring; diff --git a/tests/qt_types_standalone/rust/src/qset.rs b/tests/qt_types_standalone/rust/src/qset.rs new file mode 100644 index 000000000..38aeda5d4 --- /dev/null +++ b/tests/qt_types_standalone/rust/src/qset.rs @@ -0,0 +1,44 @@ +// SPDX-FileCopyrightText: 2022 Klarälvdalens Datakonsult AB, a KDAB Group company +// SPDX-FileContributor: Andrew Hayzen +// +// SPDX-License-Identifier: MIT OR Apache-2.0 + +use cxx_qt_lib::QSet; + +#[cxx::bridge] +mod qset_cxx { + // ANCHOR: book_qset + unsafe extern "C++" { + include!("cxx-qt-lib/qset.h"); + type QSet_i32 = cxx_qt_lib::QSet; + } + // ANCHOR_END: book_qset + + extern "Rust" { + fn construct_qset_i32() -> QSet_i32; + fn read_qset_i32(s: &QSet_i32) -> bool; + fn clone_qset_i32(s: &QSet_i32) -> QSet_i32; + } +} + +fn construct_qset_i32() -> QSet { + let mut s = QSet::::default(); + s.insert(1); + s.insert(1); + s.insert(3); + s.insert(3); + s +} + +fn read_qset_i32(s: &QSet) -> bool { + // Ensure that the iterator works by building a vector from it + let mut vec = s.iter().cloned().collect::>(); + + // Sort the vec as a set iterator does not have a guaranteed order + vec.sort(); + vec == vec![1, 3] +} + +fn clone_qset_i32(s: &QSet) -> QSet { + s.clone() +} From 63e24c7b1f65a60b2cfee763b8daf8fd80e84ef2 Mon Sep 17 00:00:00 2001 From: Leon Matthes Date: Wed, 23 Nov 2022 15:38:26 +0100 Subject: [PATCH 2/4] cxx-qt-lib: use CXX-style FFI for methods which can be defined Some methods can be defined via the CXX bridge so don't need a C++ proxy between. --- crates/cxx-qt-lib-headers/include/qset.h | 8 ++--- crates/cxx-qt-lib/src/types/qset/generate.sh | 30 +++++++++++-------- crates/cxx-qt-lib/src/types/qset/mod.rs | 8 ++--- crates/cxx-qt-lib/src/types/qset/qset.cpp | 18 +---------- crates/cxx-qt-lib/src/types/qset/qset_bool.rs | 15 ++++++---- crates/cxx-qt-lib/src/types/qset/qset_f32.rs | 15 ++++++---- crates/cxx-qt-lib/src/types/qset/qset_f64.rs | 15 ++++++---- crates/cxx-qt-lib/src/types/qset/qset_i16.rs | 15 ++++++---- crates/cxx-qt-lib/src/types/qset/qset_i32.rs | 15 ++++++---- crates/cxx-qt-lib/src/types/qset/qset_i8.rs | 15 ++++++---- .../cxx-qt-lib/src/types/qset/qset_qdate.rs | 15 ++++++---- .../src/types/qset/qset_qdatetime.rs | 15 ++++++---- .../cxx-qt-lib/src/types/qset/qset_qstring.rs | 15 ++++++---- .../cxx-qt-lib/src/types/qset/qset_qtime.rs | 15 ++++++---- crates/cxx-qt-lib/src/types/qset/qset_qurl.rs | 15 ++++++---- crates/cxx-qt-lib/src/types/qset/qset_u16.rs | 15 ++++++---- crates/cxx-qt-lib/src/types/qset/qset_u32.rs | 15 ++++++---- crates/cxx-qt-lib/src/types/qset/qset_u8.rs | 15 ++++++---- 18 files changed, 151 insertions(+), 123 deletions(-) diff --git a/crates/cxx-qt-lib-headers/include/qset.h b/crates/cxx-qt-lib-headers/include/qset.h index 4a1c4511a..221ffd1a9 100644 --- a/crates/cxx-qt-lib-headers/include/qset.h +++ b/crates/cxx-qt-lib-headers/include/qset.h @@ -22,7 +22,7 @@ struct rust::IsRelocatable> : std::true_type { }; -// Note on the Rust side we rename the methods to "clear" or "len" etc +// Note on the Rust side we rename the methods to "len" etc // so we need to put each set in it's own namespace otherwise the generated // CXX code collides. #define CXX_QT_QSET_METHODS(typeName, name) \ @@ -32,17 +32,13 @@ struct rust::IsRelocatable> : std::true_type namespace cxxqtlib1 { \ namespace qset_##name \ { \ - void qset_clear_##name(QSet_##name& s) noexcept; \ QSet_##name qset_clone_##name(const QSet_##name& s) noexcept; \ - bool qset_contains_##name(const QSet_##name& s, \ - const typeName& value) noexcept; \ QSet_##name qset_default_##name() noexcept; \ void qset_drop_##name(QSet_##name& s) noexcept; \ const typeName& qset_get_unchecked_##name(const QSet_##name& s, \ ::std::size_t pos) noexcept; \ void qset_insert_##name(QSet_##name& s, const typeName& value) noexcept; \ - std::size_t qset_len_##name(const QSet_##name& s) noexcept; \ - bool qset_remove_##name(QSet_##name& s, const typeName& value) noexcept; \ + ::std::size_t qset_len_##name(const QSet_##name& s) noexcept; \ } \ } \ } diff --git a/crates/cxx-qt-lib/src/types/qset/generate.sh b/crates/cxx-qt-lib/src/types/qset/generate.sh index 4a55b8251..0287c2463 100755 --- a/crates/cxx-qt-lib/src/types/qset/generate.sh +++ b/crates/cxx-qt-lib/src/types/qset/generate.sh @@ -24,14 +24,19 @@ pub mod ffi { type QSet_$1 = crate::QSet<$1>; } + unsafe extern "C++" { + #[rust_name = "cxx_clear"] + fn clear(self: &mut QSet_$1); + #[rust_name = "cxx_contains"] + fn contains(self: &QSet_$1, _: &$1) -> bool; + #[rust_name = "cxx_remove"] + fn remove(self: &mut QSet_$1, _: &$1) -> bool; + } + #[namespace = "rust::cxxqtlib1::qset_$1"] unsafe extern "C++" { - #[rust_name = "clear"] - fn qset_clear_$1(_: &mut QSet_$1); #[rust_name = "clone"] fn qset_clone_$1(_: &QSet_$1) -> QSet_$1; - #[rust_name = "contains"] - fn qset_contains_$1(_: &QSet_$1, _: &$1) -> bool; #[rust_name = "default"] fn qset_default_$1() -> QSet_$1; #[rust_name = "drop"] @@ -43,8 +48,6 @@ pub mod ffi { fn qset_insert_$1(_: &mut QSet_$1, _: &$1); #[rust_name = "len"] fn qset_len_$1(_: &QSet_$1) -> usize; - #[rust_name = "remove"] - fn qset_remove_$1(_: &mut QSet_$1, _: &$1) -> bool; } } EOF @@ -68,14 +71,19 @@ pub mod ffi { type QSet_$1 = crate::QSet<$1>; } + unsafe extern "C++" { + #[rust_name = "cxx_clear"] + fn clear(self: &mut QSet_$1); + #[rust_name = "cxx_contains"] + fn contains(self: &QSet_$1, _: &$1) -> bool; + #[rust_name = "cxx_remove"] + fn remove(self: &mut QSet_$1, _: &$1) -> bool; + } + #[namespace = "rust::cxxqtlib1::qset_$1"] unsafe extern "C++" { - #[rust_name = "clear"] - fn qset_clear_$1(_: &mut QSet_$1); #[rust_name = "clone"] fn qset_clone_$1(_: &QSet_$1) -> QSet_$1; - #[rust_name = "contains"] - fn qset_contains_$1(_: &QSet_$1, _: &$1) -> bool; #[rust_name = "default"] fn qset_default_$1() -> QSet_$1; #[rust_name = "drop"] @@ -86,8 +94,6 @@ pub mod ffi { fn qset_insert_$1(_: &mut QSet_$1, _: &$1); #[rust_name = "len"] fn qset_len_$1(_: &QSet_$1) -> usize; - #[rust_name = "remove"] - fn qset_remove_$1(_: &mut QSet_$1, _: &$1) -> bool; } } EOF diff --git a/crates/cxx-qt-lib/src/types/qset/mod.rs b/crates/cxx-qt-lib/src/types/qset/mod.rs index 89025e213..70fc29d32 100644 --- a/crates/cxx-qt-lib/src/types/qset/mod.rs +++ b/crates/cxx-qt-lib/src/types/qset/mod.rs @@ -200,7 +200,7 @@ macro_rules! impl_qset_element { type TypeId = type_id!($typeId); fn clear(set: &mut QSet) { - $module::ffi::clear(set); + set.cxx_clear() } fn clone(set: &QSet) -> QSet { @@ -208,7 +208,7 @@ macro_rules! impl_qset_element { } fn contains(set: &QSet, value: &Self) -> bool { - $module::ffi::contains(set, value) + set.cxx_contains(value) } fn default() -> QSet { @@ -232,11 +232,11 @@ macro_rules! impl_qset_element { } fn len(set: &QSet) -> usize { - $module::ffi::len(set) + $module::ffi::len(set) as usize } fn remove(set: &mut QSet, value: &Self) -> bool { - $module::ffi::remove(set, value) + set.cxx_remove(value) } } }; diff --git a/crates/cxx-qt-lib/src/types/qset/qset.cpp b/crates/cxx-qt-lib/src/types/qset/qset.cpp index 8accf00d3..db74a36db 100644 --- a/crates/cxx-qt-lib/src/types/qset/qset.cpp +++ b/crates/cxx-qt-lib/src/types/qset/qset.cpp @@ -28,22 +28,11 @@ namespace cxxqtlib1 { \ namespace qset_##name \ { \ - void qset_clear_##name(QSet_##name& s) noexcept \ - { \ - s.clear(); \ - } \ - \ QSet_##name qset_clone_##name(const QSet_##name& s) noexcept \ { \ return QSet(s); \ } \ \ - bool qset_contains_##name(const QSet_##name& s, \ - const typeName& value) noexcept \ - { \ - return s.contains(value); \ - } \ - \ QSet_##name qset_default_##name() noexcept \ { \ return QSet_##name(); \ @@ -70,12 +59,7 @@ \ ::std::size_t qset_len_##name(const QSet_##name& s) noexcept \ { \ - return static_cast<::std::size_t>(s.size()); \ - } \ - \ - bool qset_remove_##name(QSet_##name& s, const typeName& value) noexcept \ - { \ - return s.remove(value); \ + return static_cast<::std ::size_t>(s.size()); \ } \ } \ } \ diff --git a/crates/cxx-qt-lib/src/types/qset/qset_bool.rs b/crates/cxx-qt-lib/src/types/qset/qset_bool.rs index 430653aeb..f6b401ab4 100644 --- a/crates/cxx-qt-lib/src/types/qset/qset_bool.rs +++ b/crates/cxx-qt-lib/src/types/qset/qset_bool.rs @@ -10,14 +10,19 @@ pub mod ffi { type QSet_bool = crate::QSet; } + unsafe extern "C++" { + #[rust_name = "cxx_clear"] + fn clear(self: &mut QSet_bool); + #[rust_name = "cxx_contains"] + fn contains(self: &QSet_bool, _: &bool) -> bool; + #[rust_name = "cxx_remove"] + fn remove(self: &mut QSet_bool, _: &bool) -> bool; + } + #[namespace = "rust::cxxqtlib1::qset_bool"] unsafe extern "C++" { - #[rust_name = "clear"] - fn qset_clear_bool(_: &mut QSet_bool); #[rust_name = "clone"] fn qset_clone_bool(_: &QSet_bool) -> QSet_bool; - #[rust_name = "contains"] - fn qset_contains_bool(_: &QSet_bool, _: &bool) -> bool; #[rust_name = "default"] fn qset_default_bool() -> QSet_bool; #[rust_name = "drop"] @@ -29,7 +34,5 @@ pub mod ffi { fn qset_insert_bool(_: &mut QSet_bool, _: &bool); #[rust_name = "len"] fn qset_len_bool(_: &QSet_bool) -> usize; - #[rust_name = "remove"] - fn qset_remove_bool(_: &mut QSet_bool, _: &bool) -> bool; } } diff --git a/crates/cxx-qt-lib/src/types/qset/qset_f32.rs b/crates/cxx-qt-lib/src/types/qset/qset_f32.rs index c20bcffb4..76f4da96f 100644 --- a/crates/cxx-qt-lib/src/types/qset/qset_f32.rs +++ b/crates/cxx-qt-lib/src/types/qset/qset_f32.rs @@ -10,14 +10,19 @@ pub mod ffi { type QSet_f32 = crate::QSet; } + unsafe extern "C++" { + #[rust_name = "cxx_clear"] + fn clear(self: &mut QSet_f32); + #[rust_name = "cxx_contains"] + fn contains(self: &QSet_f32, _: &f32) -> bool; + #[rust_name = "cxx_remove"] + fn remove(self: &mut QSet_f32, _: &f32) -> bool; + } + #[namespace = "rust::cxxqtlib1::qset_f32"] unsafe extern "C++" { - #[rust_name = "clear"] - fn qset_clear_f32(_: &mut QSet_f32); #[rust_name = "clone"] fn qset_clone_f32(_: &QSet_f32) -> QSet_f32; - #[rust_name = "contains"] - fn qset_contains_f32(_: &QSet_f32, _: &f32) -> bool; #[rust_name = "default"] fn qset_default_f32() -> QSet_f32; #[rust_name = "drop"] @@ -29,7 +34,5 @@ pub mod ffi { fn qset_insert_f32(_: &mut QSet_f32, _: &f32); #[rust_name = "len"] fn qset_len_f32(_: &QSet_f32) -> usize; - #[rust_name = "remove"] - fn qset_remove_f32(_: &mut QSet_f32, _: &f32) -> bool; } } diff --git a/crates/cxx-qt-lib/src/types/qset/qset_f64.rs b/crates/cxx-qt-lib/src/types/qset/qset_f64.rs index d2cb7e6b3..ba2f86e69 100644 --- a/crates/cxx-qt-lib/src/types/qset/qset_f64.rs +++ b/crates/cxx-qt-lib/src/types/qset/qset_f64.rs @@ -10,14 +10,19 @@ pub mod ffi { type QSet_f64 = crate::QSet; } + unsafe extern "C++" { + #[rust_name = "cxx_clear"] + fn clear(self: &mut QSet_f64); + #[rust_name = "cxx_contains"] + fn contains(self: &QSet_f64, _: &f64) -> bool; + #[rust_name = "cxx_remove"] + fn remove(self: &mut QSet_f64, _: &f64) -> bool; + } + #[namespace = "rust::cxxqtlib1::qset_f64"] unsafe extern "C++" { - #[rust_name = "clear"] - fn qset_clear_f64(_: &mut QSet_f64); #[rust_name = "clone"] fn qset_clone_f64(_: &QSet_f64) -> QSet_f64; - #[rust_name = "contains"] - fn qset_contains_f64(_: &QSet_f64, _: &f64) -> bool; #[rust_name = "default"] fn qset_default_f64() -> QSet_f64; #[rust_name = "drop"] @@ -29,7 +34,5 @@ pub mod ffi { fn qset_insert_f64(_: &mut QSet_f64, _: &f64); #[rust_name = "len"] fn qset_len_f64(_: &QSet_f64) -> usize; - #[rust_name = "remove"] - fn qset_remove_f64(_: &mut QSet_f64, _: &f64) -> bool; } } diff --git a/crates/cxx-qt-lib/src/types/qset/qset_i16.rs b/crates/cxx-qt-lib/src/types/qset/qset_i16.rs index 6664919f5..1593859cf 100644 --- a/crates/cxx-qt-lib/src/types/qset/qset_i16.rs +++ b/crates/cxx-qt-lib/src/types/qset/qset_i16.rs @@ -10,14 +10,19 @@ pub mod ffi { type QSet_i16 = crate::QSet; } + unsafe extern "C++" { + #[rust_name = "cxx_clear"] + fn clear(self: &mut QSet_i16); + #[rust_name = "cxx_contains"] + fn contains(self: &QSet_i16, _: &i16) -> bool; + #[rust_name = "cxx_remove"] + fn remove(self: &mut QSet_i16, _: &i16) -> bool; + } + #[namespace = "rust::cxxqtlib1::qset_i16"] unsafe extern "C++" { - #[rust_name = "clear"] - fn qset_clear_i16(_: &mut QSet_i16); #[rust_name = "clone"] fn qset_clone_i16(_: &QSet_i16) -> QSet_i16; - #[rust_name = "contains"] - fn qset_contains_i16(_: &QSet_i16, _: &i16) -> bool; #[rust_name = "default"] fn qset_default_i16() -> QSet_i16; #[rust_name = "drop"] @@ -29,7 +34,5 @@ pub mod ffi { fn qset_insert_i16(_: &mut QSet_i16, _: &i16); #[rust_name = "len"] fn qset_len_i16(_: &QSet_i16) -> usize; - #[rust_name = "remove"] - fn qset_remove_i16(_: &mut QSet_i16, _: &i16) -> bool; } } diff --git a/crates/cxx-qt-lib/src/types/qset/qset_i32.rs b/crates/cxx-qt-lib/src/types/qset/qset_i32.rs index dfc4fa791..2411a69da 100644 --- a/crates/cxx-qt-lib/src/types/qset/qset_i32.rs +++ b/crates/cxx-qt-lib/src/types/qset/qset_i32.rs @@ -10,14 +10,19 @@ pub mod ffi { type QSet_i32 = crate::QSet; } + unsafe extern "C++" { + #[rust_name = "cxx_clear"] + fn clear(self: &mut QSet_i32); + #[rust_name = "cxx_contains"] + fn contains(self: &QSet_i32, _: &i32) -> bool; + #[rust_name = "cxx_remove"] + fn remove(self: &mut QSet_i32, _: &i32) -> bool; + } + #[namespace = "rust::cxxqtlib1::qset_i32"] unsafe extern "C++" { - #[rust_name = "clear"] - fn qset_clear_i32(_: &mut QSet_i32); #[rust_name = "clone"] fn qset_clone_i32(_: &QSet_i32) -> QSet_i32; - #[rust_name = "contains"] - fn qset_contains_i32(_: &QSet_i32, _: &i32) -> bool; #[rust_name = "default"] fn qset_default_i32() -> QSet_i32; #[rust_name = "drop"] @@ -29,7 +34,5 @@ pub mod ffi { fn qset_insert_i32(_: &mut QSet_i32, _: &i32); #[rust_name = "len"] fn qset_len_i32(_: &QSet_i32) -> usize; - #[rust_name = "remove"] - fn qset_remove_i32(_: &mut QSet_i32, _: &i32) -> bool; } } diff --git a/crates/cxx-qt-lib/src/types/qset/qset_i8.rs b/crates/cxx-qt-lib/src/types/qset/qset_i8.rs index 5d038e233..ccdcbe04d 100644 --- a/crates/cxx-qt-lib/src/types/qset/qset_i8.rs +++ b/crates/cxx-qt-lib/src/types/qset/qset_i8.rs @@ -10,14 +10,19 @@ pub mod ffi { type QSet_i8 = crate::QSet; } + unsafe extern "C++" { + #[rust_name = "cxx_clear"] + fn clear(self: &mut QSet_i8); + #[rust_name = "cxx_contains"] + fn contains(self: &QSet_i8, _: &i8) -> bool; + #[rust_name = "cxx_remove"] + fn remove(self: &mut QSet_i8, _: &i8) -> bool; + } + #[namespace = "rust::cxxqtlib1::qset_i8"] unsafe extern "C++" { - #[rust_name = "clear"] - fn qset_clear_i8(_: &mut QSet_i8); #[rust_name = "clone"] fn qset_clone_i8(_: &QSet_i8) -> QSet_i8; - #[rust_name = "contains"] - fn qset_contains_i8(_: &QSet_i8, _: &i8) -> bool; #[rust_name = "default"] fn qset_default_i8() -> QSet_i8; #[rust_name = "drop"] @@ -29,7 +34,5 @@ pub mod ffi { fn qset_insert_i8(_: &mut QSet_i8, _: &i8); #[rust_name = "len"] fn qset_len_i8(_: &QSet_i8) -> usize; - #[rust_name = "remove"] - fn qset_remove_i8(_: &mut QSet_i8, _: &i8) -> bool; } } diff --git a/crates/cxx-qt-lib/src/types/qset/qset_qdate.rs b/crates/cxx-qt-lib/src/types/qset/qset_qdate.rs index 530546ac7..7788d9bcc 100644 --- a/crates/cxx-qt-lib/src/types/qset/qset_qdate.rs +++ b/crates/cxx-qt-lib/src/types/qset/qset_qdate.rs @@ -13,14 +13,19 @@ pub mod ffi { type QSet_QDate = crate::QSet; } + unsafe extern "C++" { + #[rust_name = "cxx_clear"] + fn clear(self: &mut QSet_QDate); + #[rust_name = "cxx_contains"] + fn contains(self: &QSet_QDate, _: &QDate) -> bool; + #[rust_name = "cxx_remove"] + fn remove(self: &mut QSet_QDate, _: &QDate) -> bool; + } + #[namespace = "rust::cxxqtlib1::qset_QDate"] unsafe extern "C++" { - #[rust_name = "clear"] - fn qset_clear_QDate(_: &mut QSet_QDate); #[rust_name = "clone"] fn qset_clone_QDate(_: &QSet_QDate) -> QSet_QDate; - #[rust_name = "contains"] - fn qset_contains_QDate(_: &QSet_QDate, _: &QDate) -> bool; #[rust_name = "default"] fn qset_default_QDate() -> QSet_QDate; #[rust_name = "drop"] @@ -31,7 +36,5 @@ pub mod ffi { fn qset_insert_QDate(_: &mut QSet_QDate, _: &QDate); #[rust_name = "len"] fn qset_len_QDate(_: &QSet_QDate) -> usize; - #[rust_name = "remove"] - fn qset_remove_QDate(_: &mut QSet_QDate, _: &QDate) -> bool; } } diff --git a/crates/cxx-qt-lib/src/types/qset/qset_qdatetime.rs b/crates/cxx-qt-lib/src/types/qset/qset_qdatetime.rs index bf1371c2f..9a8a718e8 100644 --- a/crates/cxx-qt-lib/src/types/qset/qset_qdatetime.rs +++ b/crates/cxx-qt-lib/src/types/qset/qset_qdatetime.rs @@ -13,14 +13,19 @@ pub mod ffi { type QSet_QDateTime = crate::QSet; } + unsafe extern "C++" { + #[rust_name = "cxx_clear"] + fn clear(self: &mut QSet_QDateTime); + #[rust_name = "cxx_contains"] + fn contains(self: &QSet_QDateTime, _: &QDateTime) -> bool; + #[rust_name = "cxx_remove"] + fn remove(self: &mut QSet_QDateTime, _: &QDateTime) -> bool; + } + #[namespace = "rust::cxxqtlib1::qset_QDateTime"] unsafe extern "C++" { - #[rust_name = "clear"] - fn qset_clear_QDateTime(_: &mut QSet_QDateTime); #[rust_name = "clone"] fn qset_clone_QDateTime(_: &QSet_QDateTime) -> QSet_QDateTime; - #[rust_name = "contains"] - fn qset_contains_QDateTime(_: &QSet_QDateTime, _: &QDateTime) -> bool; #[rust_name = "default"] fn qset_default_QDateTime() -> QSet_QDateTime; #[rust_name = "drop"] @@ -31,7 +36,5 @@ pub mod ffi { fn qset_insert_QDateTime(_: &mut QSet_QDateTime, _: &QDateTime); #[rust_name = "len"] fn qset_len_QDateTime(_: &QSet_QDateTime) -> usize; - #[rust_name = "remove"] - fn qset_remove_QDateTime(_: &mut QSet_QDateTime, _: &QDateTime) -> bool; } } diff --git a/crates/cxx-qt-lib/src/types/qset/qset_qstring.rs b/crates/cxx-qt-lib/src/types/qset/qset_qstring.rs index e6031e176..b215ea842 100644 --- a/crates/cxx-qt-lib/src/types/qset/qset_qstring.rs +++ b/crates/cxx-qt-lib/src/types/qset/qset_qstring.rs @@ -13,14 +13,19 @@ pub mod ffi { type QSet_QString = crate::QSet; } + unsafe extern "C++" { + #[rust_name = "cxx_clear"] + fn clear(self: &mut QSet_QString); + #[rust_name = "cxx_contains"] + fn contains(self: &QSet_QString, _: &QString) -> bool; + #[rust_name = "cxx_remove"] + fn remove(self: &mut QSet_QString, _: &QString) -> bool; + } + #[namespace = "rust::cxxqtlib1::qset_QString"] unsafe extern "C++" { - #[rust_name = "clear"] - fn qset_clear_QString(_: &mut QSet_QString); #[rust_name = "clone"] fn qset_clone_QString(_: &QSet_QString) -> QSet_QString; - #[rust_name = "contains"] - fn qset_contains_QString(_: &QSet_QString, _: &QString) -> bool; #[rust_name = "default"] fn qset_default_QString() -> QSet_QString; #[rust_name = "drop"] @@ -31,7 +36,5 @@ pub mod ffi { fn qset_insert_QString(_: &mut QSet_QString, _: &QString); #[rust_name = "len"] fn qset_len_QString(_: &QSet_QString) -> usize; - #[rust_name = "remove"] - fn qset_remove_QString(_: &mut QSet_QString, _: &QString) -> bool; } } diff --git a/crates/cxx-qt-lib/src/types/qset/qset_qtime.rs b/crates/cxx-qt-lib/src/types/qset/qset_qtime.rs index 4116ed1fe..46d82f2f1 100644 --- a/crates/cxx-qt-lib/src/types/qset/qset_qtime.rs +++ b/crates/cxx-qt-lib/src/types/qset/qset_qtime.rs @@ -13,14 +13,19 @@ pub mod ffi { type QSet_QTime = crate::QSet; } + unsafe extern "C++" { + #[rust_name = "cxx_clear"] + fn clear(self: &mut QSet_QTime); + #[rust_name = "cxx_contains"] + fn contains(self: &QSet_QTime, _: &QTime) -> bool; + #[rust_name = "cxx_remove"] + fn remove(self: &mut QSet_QTime, _: &QTime) -> bool; + } + #[namespace = "rust::cxxqtlib1::qset_QTime"] unsafe extern "C++" { - #[rust_name = "clear"] - fn qset_clear_QTime(_: &mut QSet_QTime); #[rust_name = "clone"] fn qset_clone_QTime(_: &QSet_QTime) -> QSet_QTime; - #[rust_name = "contains"] - fn qset_contains_QTime(_: &QSet_QTime, _: &QTime) -> bool; #[rust_name = "default"] fn qset_default_QTime() -> QSet_QTime; #[rust_name = "drop"] @@ -31,7 +36,5 @@ pub mod ffi { fn qset_insert_QTime(_: &mut QSet_QTime, _: &QTime); #[rust_name = "len"] fn qset_len_QTime(_: &QSet_QTime) -> usize; - #[rust_name = "remove"] - fn qset_remove_QTime(_: &mut QSet_QTime, _: &QTime) -> bool; } } diff --git a/crates/cxx-qt-lib/src/types/qset/qset_qurl.rs b/crates/cxx-qt-lib/src/types/qset/qset_qurl.rs index cb0675665..2e0f38def 100644 --- a/crates/cxx-qt-lib/src/types/qset/qset_qurl.rs +++ b/crates/cxx-qt-lib/src/types/qset/qset_qurl.rs @@ -13,14 +13,19 @@ pub mod ffi { type QSet_QUrl = crate::QSet; } + unsafe extern "C++" { + #[rust_name = "cxx_clear"] + fn clear(self: &mut QSet_QUrl); + #[rust_name = "cxx_contains"] + fn contains(self: &QSet_QUrl, _: &QUrl) -> bool; + #[rust_name = "cxx_remove"] + fn remove(self: &mut QSet_QUrl, _: &QUrl) -> bool; + } + #[namespace = "rust::cxxqtlib1::qset_QUrl"] unsafe extern "C++" { - #[rust_name = "clear"] - fn qset_clear_QUrl(_: &mut QSet_QUrl); #[rust_name = "clone"] fn qset_clone_QUrl(_: &QSet_QUrl) -> QSet_QUrl; - #[rust_name = "contains"] - fn qset_contains_QUrl(_: &QSet_QUrl, _: &QUrl) -> bool; #[rust_name = "default"] fn qset_default_QUrl() -> QSet_QUrl; #[rust_name = "drop"] @@ -31,7 +36,5 @@ pub mod ffi { fn qset_insert_QUrl(_: &mut QSet_QUrl, _: &QUrl); #[rust_name = "len"] fn qset_len_QUrl(_: &QSet_QUrl) -> usize; - #[rust_name = "remove"] - fn qset_remove_QUrl(_: &mut QSet_QUrl, _: &QUrl) -> bool; } } diff --git a/crates/cxx-qt-lib/src/types/qset/qset_u16.rs b/crates/cxx-qt-lib/src/types/qset/qset_u16.rs index 6c62895a1..588ebe9b5 100644 --- a/crates/cxx-qt-lib/src/types/qset/qset_u16.rs +++ b/crates/cxx-qt-lib/src/types/qset/qset_u16.rs @@ -10,14 +10,19 @@ pub mod ffi { type QSet_u16 = crate::QSet; } + unsafe extern "C++" { + #[rust_name = "cxx_clear"] + fn clear(self: &mut QSet_u16); + #[rust_name = "cxx_contains"] + fn contains(self: &QSet_u16, _: &u16) -> bool; + #[rust_name = "cxx_remove"] + fn remove(self: &mut QSet_u16, _: &u16) -> bool; + } + #[namespace = "rust::cxxqtlib1::qset_u16"] unsafe extern "C++" { - #[rust_name = "clear"] - fn qset_clear_u16(_: &mut QSet_u16); #[rust_name = "clone"] fn qset_clone_u16(_: &QSet_u16) -> QSet_u16; - #[rust_name = "contains"] - fn qset_contains_u16(_: &QSet_u16, _: &u16) -> bool; #[rust_name = "default"] fn qset_default_u16() -> QSet_u16; #[rust_name = "drop"] @@ -29,7 +34,5 @@ pub mod ffi { fn qset_insert_u16(_: &mut QSet_u16, _: &u16); #[rust_name = "len"] fn qset_len_u16(_: &QSet_u16) -> usize; - #[rust_name = "remove"] - fn qset_remove_u16(_: &mut QSet_u16, _: &u16) -> bool; } } diff --git a/crates/cxx-qt-lib/src/types/qset/qset_u32.rs b/crates/cxx-qt-lib/src/types/qset/qset_u32.rs index 847f05f45..649020e10 100644 --- a/crates/cxx-qt-lib/src/types/qset/qset_u32.rs +++ b/crates/cxx-qt-lib/src/types/qset/qset_u32.rs @@ -10,14 +10,19 @@ pub mod ffi { type QSet_u32 = crate::QSet; } + unsafe extern "C++" { + #[rust_name = "cxx_clear"] + fn clear(self: &mut QSet_u32); + #[rust_name = "cxx_contains"] + fn contains(self: &QSet_u32, _: &u32) -> bool; + #[rust_name = "cxx_remove"] + fn remove(self: &mut QSet_u32, _: &u32) -> bool; + } + #[namespace = "rust::cxxqtlib1::qset_u32"] unsafe extern "C++" { - #[rust_name = "clear"] - fn qset_clear_u32(_: &mut QSet_u32); #[rust_name = "clone"] fn qset_clone_u32(_: &QSet_u32) -> QSet_u32; - #[rust_name = "contains"] - fn qset_contains_u32(_: &QSet_u32, _: &u32) -> bool; #[rust_name = "default"] fn qset_default_u32() -> QSet_u32; #[rust_name = "drop"] @@ -29,7 +34,5 @@ pub mod ffi { fn qset_insert_u32(_: &mut QSet_u32, _: &u32); #[rust_name = "len"] fn qset_len_u32(_: &QSet_u32) -> usize; - #[rust_name = "remove"] - fn qset_remove_u32(_: &mut QSet_u32, _: &u32) -> bool; } } diff --git a/crates/cxx-qt-lib/src/types/qset/qset_u8.rs b/crates/cxx-qt-lib/src/types/qset/qset_u8.rs index c2b32d8ca..b69be628d 100644 --- a/crates/cxx-qt-lib/src/types/qset/qset_u8.rs +++ b/crates/cxx-qt-lib/src/types/qset/qset_u8.rs @@ -10,14 +10,19 @@ pub mod ffi { type QSet_u8 = crate::QSet; } + unsafe extern "C++" { + #[rust_name = "cxx_clear"] + fn clear(self: &mut QSet_u8); + #[rust_name = "cxx_contains"] + fn contains(self: &QSet_u8, _: &u8) -> bool; + #[rust_name = "cxx_remove"] + fn remove(self: &mut QSet_u8, _: &u8) -> bool; + } + #[namespace = "rust::cxxqtlib1::qset_u8"] unsafe extern "C++" { - #[rust_name = "clear"] - fn qset_clear_u8(_: &mut QSet_u8); #[rust_name = "clone"] fn qset_clone_u8(_: &QSet_u8) -> QSet_u8; - #[rust_name = "contains"] - fn qset_contains_u8(_: &QSet_u8, _: &u8) -> bool; #[rust_name = "default"] fn qset_default_u8() -> QSet_u8; #[rust_name = "drop"] @@ -29,7 +34,5 @@ pub mod ffi { fn qset_insert_u8(_: &mut QSet_u8, _: &u8); #[rust_name = "len"] fn qset_len_u8(_: &QSet_u8) -> usize; - #[rust_name = "remove"] - fn qset_remove_u8(_: &mut QSet_u8, _: &u8) -> bool; } } From e8eb3eedff83acf095a53cf2e8d4fcad898c7593 Mon Sep 17 00:00:00 2001 From: Leon Matthes Date: Wed, 23 Nov 2022 16:42:52 +0100 Subject: [PATCH 3/4] cxx-qt-lib: Use template methods for QSet methods that can't be defined Methods that can't be defined using CXX use template methods. --- crates/cxx-qt-lib-headers/include/qset.h | 106 ++++++++++++------ crates/cxx-qt-lib/src/types/qset/generate.sh | 100 ++++++++++++----- crates/cxx-qt-lib/src/types/qset/mod.rs | 14 +-- crates/cxx-qt-lib/src/types/qset/qset.cpp | 72 +++--------- crates/cxx-qt-lib/src/types/qset/qset_bool.rs | 50 ++++++--- crates/cxx-qt-lib/src/types/qset/qset_f32.rs | 50 ++++++--- crates/cxx-qt-lib/src/types/qset/qset_f64.rs | 50 ++++++--- crates/cxx-qt-lib/src/types/qset/qset_i16.rs | 50 ++++++--- crates/cxx-qt-lib/src/types/qset/qset_i32.rs | 50 ++++++--- crates/cxx-qt-lib/src/types/qset/qset_i8.rs | 50 ++++++--- .../cxx-qt-lib/src/types/qset/qset_qdate.rs | 50 ++++++--- .../src/types/qset/qset_qdatetime.rs | 50 ++++++--- .../cxx-qt-lib/src/types/qset/qset_qstring.rs | 50 ++++++--- .../cxx-qt-lib/src/types/qset/qset_qtime.rs | 50 ++++++--- crates/cxx-qt-lib/src/types/qset/qset_qurl.rs | 50 ++++++--- crates/cxx-qt-lib/src/types/qset/qset_u16.rs | 50 ++++++--- crates/cxx-qt-lib/src/types/qset/qset_u32.rs | 50 ++++++--- crates/cxx-qt-lib/src/types/qset/qset_u8.rs | 50 ++++++--- 18 files changed, 684 insertions(+), 308 deletions(-) diff --git a/crates/cxx-qt-lib-headers/include/qset.h b/crates/cxx-qt-lib-headers/include/qset.h index 221ffd1a9..fb368b442 100644 --- a/crates/cxx-qt-lib-headers/include/qset.h +++ b/crates/cxx-qt-lib-headers/include/qset.h @@ -22,38 +22,74 @@ struct rust::IsRelocatable> : std::true_type { }; -// Note on the Rust side we rename the methods to "len" etc -// so we need to put each set in it's own namespace otherwise the generated -// CXX code collides. -#define CXX_QT_QSET_METHODS(typeName, name) \ - using QSet_##name = QSet; \ - \ - namespace rust { \ - namespace cxxqtlib1 { \ - namespace qset_##name \ - { \ - QSet_##name qset_clone_##name(const QSet_##name& s) noexcept; \ - QSet_##name qset_default_##name() noexcept; \ - void qset_drop_##name(QSet_##name& s) noexcept; \ - const typeName& qset_get_unchecked_##name(const QSet_##name& s, \ - ::std::size_t pos) noexcept; \ - void qset_insert_##name(QSet_##name& s, const typeName& value) noexcept; \ - ::std::size_t qset_len_##name(const QSet_##name& s) noexcept; \ - } \ - } \ - } - -CXX_QT_QSET_METHODS(bool, bool); -CXX_QT_QSET_METHODS(float, f32); -CXX_QT_QSET_METHODS(double, f64); -CXX_QT_QSET_METHODS(::qint8, i8); -CXX_QT_QSET_METHODS(::qint16, i16); -CXX_QT_QSET_METHODS(::qint32, i32); -CXX_QT_QSET_METHODS(::QDate, QDate); -CXX_QT_QSET_METHODS(::QDateTime, QDateTime); -CXX_QT_QSET_METHODS(::QString, QString); -CXX_QT_QSET_METHODS(::QTime, QTime); -CXX_QT_QSET_METHODS(::QUrl, QUrl); -CXX_QT_QSET_METHODS(::quint8, u8); -CXX_QT_QSET_METHODS(::quint16, u16); -CXX_QT_QSET_METHODS(::quint32, u32); +namespace rust { +namespace cxxqtlib1 { + +template +QSet +qset_clone(const QSet& s) noexcept +{ + return QSet(s); +} + +template +QSet +qset_default() noexcept +{ + return QSet(); +} + +template +void +qset_drop(QSet& s) noexcept +{ + s.~QSet(); +} + +template +const T& +qset_get_unchecked(const QSet& s, ::std::size_t pos) noexcept +{ + Q_ASSERT(pos < static_cast<::std::size_t>(s.size())); + auto it = s.cbegin(); + std::advance(it, pos); + return *it; +} + +template +void +qset_insert(QSet& s, const T& value) noexcept +{ + s.insert(value); +} + +template +::std::size_t +qset_len(const QSet& s) noexcept +{ + // In Qt 5 the type was int now it is qsizetype, so we need to ensure the type + // is the same for CXX +#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)) + return s.size(); +#else + return static_cast<::std ::size_t>(s.size()); +#endif +} + +} +} + +using QSet_bool = QSet; +using QSet_f32 = QSet; +using QSet_f64 = QSet; +using QSet_i8 = QSet<::qint8>; +using QSet_i16 = QSet<::qint16>; +using QSet_i32 = QSet<::qint32>; +using QSet_QDate = QSet<::QDate>; +using QSet_QDateTime = QSet<::QDateTime>; +using QSet_QString = QSet<::QString>; +using QSet_QTime = QSet<::QTime>; +using QSet_QUrl = QSet<::QUrl>; +using QSet_u8 = QSet<::quint8>; +using QSet_u16 = QSet<::quint16>; +using QSet_u32 = QSet<::quint32>; diff --git a/crates/cxx-qt-lib/src/types/qset/generate.sh b/crates/cxx-qt-lib/src/types/qset/generate.sh index 0287c2463..6fdc3be3d 100755 --- a/crates/cxx-qt-lib/src/types/qset/generate.sh +++ b/crates/cxx-qt-lib/src/types/qset/generate.sh @@ -33,23 +33,47 @@ pub mod ffi { fn remove(self: &mut QSet_$1, _: &$1) -> bool; } - #[namespace = "rust::cxxqtlib1::qset_$1"] + #[namespace = "rust::cxxqtlib1"] unsafe extern "C++" { - #[rust_name = "clone"] - fn qset_clone_$1(_: &QSet_$1) -> QSet_$1; - #[rust_name = "default"] - fn qset_default_$1() -> QSet_$1; - #[rust_name = "drop"] - fn qset_drop_$1(_: &mut QSet_$1); - #[rust_name = "get_unchecked"] + #[rust_name = "clone_$1"] + fn qset_clone(_: &QSet_$1) -> QSet_$1; + #[rust_name = "default_$1"] + fn qset_default() -> QSet_$1; + #[rust_name = "drop_$1"] + fn qset_drop(_: &mut QSet_$1); + #[rust_name = "get_unchecked_$1"] #[allow(clippy::needless_lifetimes)] - unsafe fn qset_get_unchecked_$1<'a>(set: &'a QSet_$1, pos: usize) -> &'a $1; - #[rust_name = "insert"] - fn qset_insert_$1(_: &mut QSet_$1, _: &$1); - #[rust_name = "len"] - fn qset_len_$1(_: &QSet_$1) -> usize; + unsafe fn qset_get_unchecked<'a>(set: &'a QSet_$1, pos: usize) -> &'a $1; + #[rust_name = "insert_$1"] + fn qset_insert(_: &mut QSet_$1, _: &$1); + #[rust_name = "len_$1"] + fn qset_len(_: &QSet_$1) -> usize; } } + +pub(crate) fn clone(s: &ffi::QSet_$1) -> ffi::QSet_$1 { + ffi::clone_$1(s) +} + +pub(crate) fn default() -> ffi::QSet_$1 { + ffi::default_$1() +} + +pub(crate) fn drop(s: &mut ffi::QSet_$1) { + ffi::drop_$1(s); +} + +pub(crate) unsafe fn get_unchecked(s: &ffi::QSet_$1, pos: usize) -> &$1 { + ffi::get_unchecked_$1(s, pos) +} + +pub(crate) fn insert(s: &mut ffi::QSet_$1, value: &$1) { + ffi::insert_$1(s, value); +} + +pub(crate) fn len(s: &ffi::QSet_$1) -> usize { + ffi::len_$1(s) +} EOF rustfmt "$SCRIPTPATH/qset_$1.rs" } @@ -80,22 +104,46 @@ pub mod ffi { fn remove(self: &mut QSet_$1, _: &$1) -> bool; } - #[namespace = "rust::cxxqtlib1::qset_$1"] + #[namespace = "rust::cxxqtlib1"] unsafe extern "C++" { - #[rust_name = "clone"] - fn qset_clone_$1(_: &QSet_$1) -> QSet_$1; - #[rust_name = "default"] - fn qset_default_$1() -> QSet_$1; - #[rust_name = "drop"] - fn qset_drop_$1(_: &mut QSet_$1); - #[rust_name = "get_unchecked"] - unsafe fn qset_get_unchecked_$1(set: &QSet_$1, pos: usize) -> &$1; - #[rust_name = "insert"] - fn qset_insert_$1(_: &mut QSet_$1, _: &$1); - #[rust_name = "len"] - fn qset_len_$1(_: &QSet_$1) -> usize; + #[rust_name = "clone_$1"] + fn qset_clone(_: &QSet_$1) -> QSet_$1; + #[rust_name = "default_$1"] + fn qset_default() -> QSet_$1; + #[rust_name = "drop_$1"] + fn qset_drop(_: &mut QSet_$1); + #[rust_name = "get_unchecked_$1"] + unsafe fn qset_get_unchecked(set: &QSet_$1, pos: usize) -> &$1; + #[rust_name = "insert_$1"] + fn qset_insert(_: &mut QSet_$1, _: &$1); + #[rust_name = "len_$1"] + fn qset_len(_: &QSet_$1) -> usize; } } + +pub(crate) fn clone(s: &ffi::QSet_$1) -> ffi::QSet_$1 { + ffi::clone_$1(s) +} + +pub(crate) fn default() -> ffi::QSet_$1 { + ffi::default_$1() +} + +pub(crate) fn drop(s: &mut ffi::QSet_$1) { + ffi::drop_$1(s); +} + +pub(crate) unsafe fn get_unchecked(s: &ffi::QSet_$1, pos: usize) -> &ffi::$1 { + ffi::get_unchecked_$1(s, pos) +} + +pub(crate) fn insert(s: &mut ffi::QSet_$1, value: &ffi::$1) { + ffi::insert_$1(s, value); +} + +pub(crate) fn len(s: &ffi::QSet_$1) -> usize { + ffi::len_$1(s) +} EOF rustfmt "$SCRIPTPATH/qset_$2.rs" } diff --git a/crates/cxx-qt-lib/src/types/qset/mod.rs b/crates/cxx-qt-lib/src/types/qset/mod.rs index 70fc29d32..9020849e3 100644 --- a/crates/cxx-qt-lib/src/types/qset/mod.rs +++ b/crates/cxx-qt-lib/src/types/qset/mod.rs @@ -204,7 +204,7 @@ macro_rules! impl_qset_element { } fn clone(set: &QSet) -> QSet { - $module::ffi::clone(set) + $module::clone(set) } fn contains(set: &QSet, value: &Self) -> bool { @@ -212,27 +212,27 @@ macro_rules! impl_qset_element { } fn default() -> QSet { - $module::ffi::default() + $module::default() } fn drop(set: &mut QSet) { - $module::ffi::drop(set); + $module::drop(set); } unsafe fn get_unchecked(set: &QSet, pos: usize) -> &Self { - $module::ffi::get_unchecked(set, pos) + $module::get_unchecked(set, pos) } fn insert(set: &mut QSet, value: Self) { - $module::ffi::insert(set, &value); + $module::insert(set, &value); } fn insert_clone(set: &mut QSet, value: &Self) { - $module::ffi::insert(set, value); + $module::insert(set, value); } fn len(set: &QSet) -> usize { - $module::ffi::len(set) as usize + $module::len(set) } fn remove(set: &mut QSet, value: &Self) -> bool { diff --git a/crates/cxx-qt-lib/src/types/qset/qset.cpp b/crates/cxx-qt-lib/src/types/qset/qset.cpp index db74a36db..739238649 100644 --- a/crates/cxx-qt-lib/src/types/qset/qset.cpp +++ b/crates/cxx-qt-lib/src/types/qset/qset.cpp @@ -21,61 +21,17 @@ static_assert(std::is_copy_assignable::value); \ static_assert(std::is_copy_constructible::value); -#define CXX_QT_QSET_METHODS_IMPL(typeName, name) \ - CXX_QT_QSET_ASSERTS(typeName, name); \ - \ - namespace rust { \ - namespace cxxqtlib1 { \ - namespace qset_##name \ - { \ - QSet_##name qset_clone_##name(const QSet_##name& s) noexcept \ - { \ - return QSet(s); \ - } \ - \ - QSet_##name qset_default_##name() noexcept \ - { \ - return QSet_##name(); \ - } \ - \ - void qset_drop_##name(QSet_##name& s) noexcept \ - { \ - s.~QSet_##name(); \ - } \ - \ - const typeName& qset_get_unchecked_##name(const QSet_##name& s, \ - ::std::size_t pos) noexcept \ - { \ - Q_ASSERT(pos < static_cast<::std::size_t>(s.size())); \ - auto it = s.cbegin(); \ - std::advance(it, pos); \ - return *it; \ - } \ - \ - void qset_insert_##name(QSet_##name& s, const typeName& value) noexcept \ - { \ - s.insert(value); \ - } \ - \ - ::std::size_t qset_len_##name(const QSet_##name& s) noexcept \ - { \ - return static_cast<::std ::size_t>(s.size()); \ - } \ - } \ - } \ - } - -CXX_QT_QSET_METHODS_IMPL(bool, bool); -CXX_QT_QSET_METHODS_IMPL(float, f32); -CXX_QT_QSET_METHODS_IMPL(double, f64); -CXX_QT_QSET_METHODS_IMPL(::qint8, i8); -CXX_QT_QSET_METHODS_IMPL(::qint16, i16); -CXX_QT_QSET_METHODS_IMPL(::qint32, i32); -CXX_QT_QSET_METHODS_IMPL(::QDate, QDate); -CXX_QT_QSET_METHODS_IMPL(::QDateTime, QDateTime); -CXX_QT_QSET_METHODS_IMPL(::QString, QString); -CXX_QT_QSET_METHODS_IMPL(::QTime, QTime); -CXX_QT_QSET_METHODS_IMPL(::QUrl, QUrl); -CXX_QT_QSET_METHODS_IMPL(::quint8, u8); -CXX_QT_QSET_METHODS_IMPL(::quint16, u16); -CXX_QT_QSET_METHODS_IMPL(::quint32, u32); +CXX_QT_QSET_ASSERTS(bool, bool); +CXX_QT_QSET_ASSERTS(float, f32); +CXX_QT_QSET_ASSERTS(double, f64); +CXX_QT_QSET_ASSERTS(::qint8, i8); +CXX_QT_QSET_ASSERTS(::qint16, i16); +CXX_QT_QSET_ASSERTS(::qint32, i32); +CXX_QT_QSET_ASSERTS(::QDate, QDate); +CXX_QT_QSET_ASSERTS(::QDateTime, QDateTime); +CXX_QT_QSET_ASSERTS(::QString, QString); +CXX_QT_QSET_ASSERTS(::QTime, QTime); +CXX_QT_QSET_ASSERTS(::QUrl, QUrl); +CXX_QT_QSET_ASSERTS(::quint8, u8); +CXX_QT_QSET_ASSERTS(::quint16, u16); +CXX_QT_QSET_ASSERTS(::quint32, u32); diff --git a/crates/cxx-qt-lib/src/types/qset/qset_bool.rs b/crates/cxx-qt-lib/src/types/qset/qset_bool.rs index f6b401ab4..e7477d65e 100644 --- a/crates/cxx-qt-lib/src/types/qset/qset_bool.rs +++ b/crates/cxx-qt-lib/src/types/qset/qset_bool.rs @@ -19,20 +19,44 @@ pub mod ffi { fn remove(self: &mut QSet_bool, _: &bool) -> bool; } - #[namespace = "rust::cxxqtlib1::qset_bool"] + #[namespace = "rust::cxxqtlib1"] unsafe extern "C++" { - #[rust_name = "clone"] - fn qset_clone_bool(_: &QSet_bool) -> QSet_bool; - #[rust_name = "default"] - fn qset_default_bool() -> QSet_bool; - #[rust_name = "drop"] - fn qset_drop_bool(_: &mut QSet_bool); - #[rust_name = "get_unchecked"] + #[rust_name = "clone_bool"] + fn qset_clone(_: &QSet_bool) -> QSet_bool; + #[rust_name = "default_bool"] + fn qset_default() -> QSet_bool; + #[rust_name = "drop_bool"] + fn qset_drop(_: &mut QSet_bool); + #[rust_name = "get_unchecked_bool"] #[allow(clippy::needless_lifetimes)] - unsafe fn qset_get_unchecked_bool<'a>(set: &'a QSet_bool, pos: usize) -> &'a bool; - #[rust_name = "insert"] - fn qset_insert_bool(_: &mut QSet_bool, _: &bool); - #[rust_name = "len"] - fn qset_len_bool(_: &QSet_bool) -> usize; + unsafe fn qset_get_unchecked<'a>(set: &'a QSet_bool, pos: usize) -> &'a bool; + #[rust_name = "insert_bool"] + fn qset_insert(_: &mut QSet_bool, _: &bool); + #[rust_name = "len_bool"] + fn qset_len(_: &QSet_bool) -> usize; } } + +pub(crate) fn clone(s: &ffi::QSet_bool) -> ffi::QSet_bool { + ffi::clone_bool(s) +} + +pub(crate) fn default() -> ffi::QSet_bool { + ffi::default_bool() +} + +pub(crate) fn drop(s: &mut ffi::QSet_bool) { + ffi::drop_bool(s); +} + +pub(crate) unsafe fn get_unchecked(s: &ffi::QSet_bool, pos: usize) -> &bool { + ffi::get_unchecked_bool(s, pos) +} + +pub(crate) fn insert(s: &mut ffi::QSet_bool, value: &bool) { + ffi::insert_bool(s, value); +} + +pub(crate) fn len(s: &ffi::QSet_bool) -> usize { + ffi::len_bool(s) +} diff --git a/crates/cxx-qt-lib/src/types/qset/qset_f32.rs b/crates/cxx-qt-lib/src/types/qset/qset_f32.rs index 76f4da96f..4c55b6e8d 100644 --- a/crates/cxx-qt-lib/src/types/qset/qset_f32.rs +++ b/crates/cxx-qt-lib/src/types/qset/qset_f32.rs @@ -19,20 +19,44 @@ pub mod ffi { fn remove(self: &mut QSet_f32, _: &f32) -> bool; } - #[namespace = "rust::cxxqtlib1::qset_f32"] + #[namespace = "rust::cxxqtlib1"] unsafe extern "C++" { - #[rust_name = "clone"] - fn qset_clone_f32(_: &QSet_f32) -> QSet_f32; - #[rust_name = "default"] - fn qset_default_f32() -> QSet_f32; - #[rust_name = "drop"] - fn qset_drop_f32(_: &mut QSet_f32); - #[rust_name = "get_unchecked"] + #[rust_name = "clone_f32"] + fn qset_clone(_: &QSet_f32) -> QSet_f32; + #[rust_name = "default_f32"] + fn qset_default() -> QSet_f32; + #[rust_name = "drop_f32"] + fn qset_drop(_: &mut QSet_f32); + #[rust_name = "get_unchecked_f32"] #[allow(clippy::needless_lifetimes)] - unsafe fn qset_get_unchecked_f32<'a>(set: &'a QSet_f32, pos: usize) -> &'a f32; - #[rust_name = "insert"] - fn qset_insert_f32(_: &mut QSet_f32, _: &f32); - #[rust_name = "len"] - fn qset_len_f32(_: &QSet_f32) -> usize; + unsafe fn qset_get_unchecked<'a>(set: &'a QSet_f32, pos: usize) -> &'a f32; + #[rust_name = "insert_f32"] + fn qset_insert(_: &mut QSet_f32, _: &f32); + #[rust_name = "len_f32"] + fn qset_len(_: &QSet_f32) -> usize; } } + +pub(crate) fn clone(s: &ffi::QSet_f32) -> ffi::QSet_f32 { + ffi::clone_f32(s) +} + +pub(crate) fn default() -> ffi::QSet_f32 { + ffi::default_f32() +} + +pub(crate) fn drop(s: &mut ffi::QSet_f32) { + ffi::drop_f32(s); +} + +pub(crate) unsafe fn get_unchecked(s: &ffi::QSet_f32, pos: usize) -> &f32 { + ffi::get_unchecked_f32(s, pos) +} + +pub(crate) fn insert(s: &mut ffi::QSet_f32, value: &f32) { + ffi::insert_f32(s, value); +} + +pub(crate) fn len(s: &ffi::QSet_f32) -> usize { + ffi::len_f32(s) +} diff --git a/crates/cxx-qt-lib/src/types/qset/qset_f64.rs b/crates/cxx-qt-lib/src/types/qset/qset_f64.rs index ba2f86e69..3fcc9518b 100644 --- a/crates/cxx-qt-lib/src/types/qset/qset_f64.rs +++ b/crates/cxx-qt-lib/src/types/qset/qset_f64.rs @@ -19,20 +19,44 @@ pub mod ffi { fn remove(self: &mut QSet_f64, _: &f64) -> bool; } - #[namespace = "rust::cxxqtlib1::qset_f64"] + #[namespace = "rust::cxxqtlib1"] unsafe extern "C++" { - #[rust_name = "clone"] - fn qset_clone_f64(_: &QSet_f64) -> QSet_f64; - #[rust_name = "default"] - fn qset_default_f64() -> QSet_f64; - #[rust_name = "drop"] - fn qset_drop_f64(_: &mut QSet_f64); - #[rust_name = "get_unchecked"] + #[rust_name = "clone_f64"] + fn qset_clone(_: &QSet_f64) -> QSet_f64; + #[rust_name = "default_f64"] + fn qset_default() -> QSet_f64; + #[rust_name = "drop_f64"] + fn qset_drop(_: &mut QSet_f64); + #[rust_name = "get_unchecked_f64"] #[allow(clippy::needless_lifetimes)] - unsafe fn qset_get_unchecked_f64<'a>(set: &'a QSet_f64, pos: usize) -> &'a f64; - #[rust_name = "insert"] - fn qset_insert_f64(_: &mut QSet_f64, _: &f64); - #[rust_name = "len"] - fn qset_len_f64(_: &QSet_f64) -> usize; + unsafe fn qset_get_unchecked<'a>(set: &'a QSet_f64, pos: usize) -> &'a f64; + #[rust_name = "insert_f64"] + fn qset_insert(_: &mut QSet_f64, _: &f64); + #[rust_name = "len_f64"] + fn qset_len(_: &QSet_f64) -> usize; } } + +pub(crate) fn clone(s: &ffi::QSet_f64) -> ffi::QSet_f64 { + ffi::clone_f64(s) +} + +pub(crate) fn default() -> ffi::QSet_f64 { + ffi::default_f64() +} + +pub(crate) fn drop(s: &mut ffi::QSet_f64) { + ffi::drop_f64(s); +} + +pub(crate) unsafe fn get_unchecked(s: &ffi::QSet_f64, pos: usize) -> &f64 { + ffi::get_unchecked_f64(s, pos) +} + +pub(crate) fn insert(s: &mut ffi::QSet_f64, value: &f64) { + ffi::insert_f64(s, value); +} + +pub(crate) fn len(s: &ffi::QSet_f64) -> usize { + ffi::len_f64(s) +} diff --git a/crates/cxx-qt-lib/src/types/qset/qset_i16.rs b/crates/cxx-qt-lib/src/types/qset/qset_i16.rs index 1593859cf..387e05d68 100644 --- a/crates/cxx-qt-lib/src/types/qset/qset_i16.rs +++ b/crates/cxx-qt-lib/src/types/qset/qset_i16.rs @@ -19,20 +19,44 @@ pub mod ffi { fn remove(self: &mut QSet_i16, _: &i16) -> bool; } - #[namespace = "rust::cxxqtlib1::qset_i16"] + #[namespace = "rust::cxxqtlib1"] unsafe extern "C++" { - #[rust_name = "clone"] - fn qset_clone_i16(_: &QSet_i16) -> QSet_i16; - #[rust_name = "default"] - fn qset_default_i16() -> QSet_i16; - #[rust_name = "drop"] - fn qset_drop_i16(_: &mut QSet_i16); - #[rust_name = "get_unchecked"] + #[rust_name = "clone_i16"] + fn qset_clone(_: &QSet_i16) -> QSet_i16; + #[rust_name = "default_i16"] + fn qset_default() -> QSet_i16; + #[rust_name = "drop_i16"] + fn qset_drop(_: &mut QSet_i16); + #[rust_name = "get_unchecked_i16"] #[allow(clippy::needless_lifetimes)] - unsafe fn qset_get_unchecked_i16<'a>(set: &'a QSet_i16, pos: usize) -> &'a i16; - #[rust_name = "insert"] - fn qset_insert_i16(_: &mut QSet_i16, _: &i16); - #[rust_name = "len"] - fn qset_len_i16(_: &QSet_i16) -> usize; + unsafe fn qset_get_unchecked<'a>(set: &'a QSet_i16, pos: usize) -> &'a i16; + #[rust_name = "insert_i16"] + fn qset_insert(_: &mut QSet_i16, _: &i16); + #[rust_name = "len_i16"] + fn qset_len(_: &QSet_i16) -> usize; } } + +pub(crate) fn clone(s: &ffi::QSet_i16) -> ffi::QSet_i16 { + ffi::clone_i16(s) +} + +pub(crate) fn default() -> ffi::QSet_i16 { + ffi::default_i16() +} + +pub(crate) fn drop(s: &mut ffi::QSet_i16) { + ffi::drop_i16(s); +} + +pub(crate) unsafe fn get_unchecked(s: &ffi::QSet_i16, pos: usize) -> &i16 { + ffi::get_unchecked_i16(s, pos) +} + +pub(crate) fn insert(s: &mut ffi::QSet_i16, value: &i16) { + ffi::insert_i16(s, value); +} + +pub(crate) fn len(s: &ffi::QSet_i16) -> usize { + ffi::len_i16(s) +} diff --git a/crates/cxx-qt-lib/src/types/qset/qset_i32.rs b/crates/cxx-qt-lib/src/types/qset/qset_i32.rs index 2411a69da..86e5f4828 100644 --- a/crates/cxx-qt-lib/src/types/qset/qset_i32.rs +++ b/crates/cxx-qt-lib/src/types/qset/qset_i32.rs @@ -19,20 +19,44 @@ pub mod ffi { fn remove(self: &mut QSet_i32, _: &i32) -> bool; } - #[namespace = "rust::cxxqtlib1::qset_i32"] + #[namespace = "rust::cxxqtlib1"] unsafe extern "C++" { - #[rust_name = "clone"] - fn qset_clone_i32(_: &QSet_i32) -> QSet_i32; - #[rust_name = "default"] - fn qset_default_i32() -> QSet_i32; - #[rust_name = "drop"] - fn qset_drop_i32(_: &mut QSet_i32); - #[rust_name = "get_unchecked"] + #[rust_name = "clone_i32"] + fn qset_clone(_: &QSet_i32) -> QSet_i32; + #[rust_name = "default_i32"] + fn qset_default() -> QSet_i32; + #[rust_name = "drop_i32"] + fn qset_drop(_: &mut QSet_i32); + #[rust_name = "get_unchecked_i32"] #[allow(clippy::needless_lifetimes)] - unsafe fn qset_get_unchecked_i32<'a>(set: &'a QSet_i32, pos: usize) -> &'a i32; - #[rust_name = "insert"] - fn qset_insert_i32(_: &mut QSet_i32, _: &i32); - #[rust_name = "len"] - fn qset_len_i32(_: &QSet_i32) -> usize; + unsafe fn qset_get_unchecked<'a>(set: &'a QSet_i32, pos: usize) -> &'a i32; + #[rust_name = "insert_i32"] + fn qset_insert(_: &mut QSet_i32, _: &i32); + #[rust_name = "len_i32"] + fn qset_len(_: &QSet_i32) -> usize; } } + +pub(crate) fn clone(s: &ffi::QSet_i32) -> ffi::QSet_i32 { + ffi::clone_i32(s) +} + +pub(crate) fn default() -> ffi::QSet_i32 { + ffi::default_i32() +} + +pub(crate) fn drop(s: &mut ffi::QSet_i32) { + ffi::drop_i32(s); +} + +pub(crate) unsafe fn get_unchecked(s: &ffi::QSet_i32, pos: usize) -> &i32 { + ffi::get_unchecked_i32(s, pos) +} + +pub(crate) fn insert(s: &mut ffi::QSet_i32, value: &i32) { + ffi::insert_i32(s, value); +} + +pub(crate) fn len(s: &ffi::QSet_i32) -> usize { + ffi::len_i32(s) +} diff --git a/crates/cxx-qt-lib/src/types/qset/qset_i8.rs b/crates/cxx-qt-lib/src/types/qset/qset_i8.rs index ccdcbe04d..d1bda4196 100644 --- a/crates/cxx-qt-lib/src/types/qset/qset_i8.rs +++ b/crates/cxx-qt-lib/src/types/qset/qset_i8.rs @@ -19,20 +19,44 @@ pub mod ffi { fn remove(self: &mut QSet_i8, _: &i8) -> bool; } - #[namespace = "rust::cxxqtlib1::qset_i8"] + #[namespace = "rust::cxxqtlib1"] unsafe extern "C++" { - #[rust_name = "clone"] - fn qset_clone_i8(_: &QSet_i8) -> QSet_i8; - #[rust_name = "default"] - fn qset_default_i8() -> QSet_i8; - #[rust_name = "drop"] - fn qset_drop_i8(_: &mut QSet_i8); - #[rust_name = "get_unchecked"] + #[rust_name = "clone_i8"] + fn qset_clone(_: &QSet_i8) -> QSet_i8; + #[rust_name = "default_i8"] + fn qset_default() -> QSet_i8; + #[rust_name = "drop_i8"] + fn qset_drop(_: &mut QSet_i8); + #[rust_name = "get_unchecked_i8"] #[allow(clippy::needless_lifetimes)] - unsafe fn qset_get_unchecked_i8<'a>(set: &'a QSet_i8, pos: usize) -> &'a i8; - #[rust_name = "insert"] - fn qset_insert_i8(_: &mut QSet_i8, _: &i8); - #[rust_name = "len"] - fn qset_len_i8(_: &QSet_i8) -> usize; + unsafe fn qset_get_unchecked<'a>(set: &'a QSet_i8, pos: usize) -> &'a i8; + #[rust_name = "insert_i8"] + fn qset_insert(_: &mut QSet_i8, _: &i8); + #[rust_name = "len_i8"] + fn qset_len(_: &QSet_i8) -> usize; } } + +pub(crate) fn clone(s: &ffi::QSet_i8) -> ffi::QSet_i8 { + ffi::clone_i8(s) +} + +pub(crate) fn default() -> ffi::QSet_i8 { + ffi::default_i8() +} + +pub(crate) fn drop(s: &mut ffi::QSet_i8) { + ffi::drop_i8(s); +} + +pub(crate) unsafe fn get_unchecked(s: &ffi::QSet_i8, pos: usize) -> &i8 { + ffi::get_unchecked_i8(s, pos) +} + +pub(crate) fn insert(s: &mut ffi::QSet_i8, value: &i8) { + ffi::insert_i8(s, value); +} + +pub(crate) fn len(s: &ffi::QSet_i8) -> usize { + ffi::len_i8(s) +} diff --git a/crates/cxx-qt-lib/src/types/qset/qset_qdate.rs b/crates/cxx-qt-lib/src/types/qset/qset_qdate.rs index 7788d9bcc..254de4bfd 100644 --- a/crates/cxx-qt-lib/src/types/qset/qset_qdate.rs +++ b/crates/cxx-qt-lib/src/types/qset/qset_qdate.rs @@ -22,19 +22,43 @@ pub mod ffi { fn remove(self: &mut QSet_QDate, _: &QDate) -> bool; } - #[namespace = "rust::cxxqtlib1::qset_QDate"] + #[namespace = "rust::cxxqtlib1"] unsafe extern "C++" { - #[rust_name = "clone"] - fn qset_clone_QDate(_: &QSet_QDate) -> QSet_QDate; - #[rust_name = "default"] - fn qset_default_QDate() -> QSet_QDate; - #[rust_name = "drop"] - fn qset_drop_QDate(_: &mut QSet_QDate); - #[rust_name = "get_unchecked"] - unsafe fn qset_get_unchecked_QDate(set: &QSet_QDate, pos: usize) -> &QDate; - #[rust_name = "insert"] - fn qset_insert_QDate(_: &mut QSet_QDate, _: &QDate); - #[rust_name = "len"] - fn qset_len_QDate(_: &QSet_QDate) -> usize; + #[rust_name = "clone_QDate"] + fn qset_clone(_: &QSet_QDate) -> QSet_QDate; + #[rust_name = "default_QDate"] + fn qset_default() -> QSet_QDate; + #[rust_name = "drop_QDate"] + fn qset_drop(_: &mut QSet_QDate); + #[rust_name = "get_unchecked_QDate"] + unsafe fn qset_get_unchecked(set: &QSet_QDate, pos: usize) -> &QDate; + #[rust_name = "insert_QDate"] + fn qset_insert(_: &mut QSet_QDate, _: &QDate); + #[rust_name = "len_QDate"] + fn qset_len(_: &QSet_QDate) -> usize; } } + +pub(crate) fn clone(s: &ffi::QSet_QDate) -> ffi::QSet_QDate { + ffi::clone_QDate(s) +} + +pub(crate) fn default() -> ffi::QSet_QDate { + ffi::default_QDate() +} + +pub(crate) fn drop(s: &mut ffi::QSet_QDate) { + ffi::drop_QDate(s); +} + +pub(crate) unsafe fn get_unchecked(s: &ffi::QSet_QDate, pos: usize) -> &ffi::QDate { + ffi::get_unchecked_QDate(s, pos) +} + +pub(crate) fn insert(s: &mut ffi::QSet_QDate, value: &ffi::QDate) { + ffi::insert_QDate(s, value); +} + +pub(crate) fn len(s: &ffi::QSet_QDate) -> usize { + ffi::len_QDate(s) +} diff --git a/crates/cxx-qt-lib/src/types/qset/qset_qdatetime.rs b/crates/cxx-qt-lib/src/types/qset/qset_qdatetime.rs index 9a8a718e8..ede5e164e 100644 --- a/crates/cxx-qt-lib/src/types/qset/qset_qdatetime.rs +++ b/crates/cxx-qt-lib/src/types/qset/qset_qdatetime.rs @@ -22,19 +22,43 @@ pub mod ffi { fn remove(self: &mut QSet_QDateTime, _: &QDateTime) -> bool; } - #[namespace = "rust::cxxqtlib1::qset_QDateTime"] + #[namespace = "rust::cxxqtlib1"] unsafe extern "C++" { - #[rust_name = "clone"] - fn qset_clone_QDateTime(_: &QSet_QDateTime) -> QSet_QDateTime; - #[rust_name = "default"] - fn qset_default_QDateTime() -> QSet_QDateTime; - #[rust_name = "drop"] - fn qset_drop_QDateTime(_: &mut QSet_QDateTime); - #[rust_name = "get_unchecked"] - unsafe fn qset_get_unchecked_QDateTime(set: &QSet_QDateTime, pos: usize) -> &QDateTime; - #[rust_name = "insert"] - fn qset_insert_QDateTime(_: &mut QSet_QDateTime, _: &QDateTime); - #[rust_name = "len"] - fn qset_len_QDateTime(_: &QSet_QDateTime) -> usize; + #[rust_name = "clone_QDateTime"] + fn qset_clone(_: &QSet_QDateTime) -> QSet_QDateTime; + #[rust_name = "default_QDateTime"] + fn qset_default() -> QSet_QDateTime; + #[rust_name = "drop_QDateTime"] + fn qset_drop(_: &mut QSet_QDateTime); + #[rust_name = "get_unchecked_QDateTime"] + unsafe fn qset_get_unchecked(set: &QSet_QDateTime, pos: usize) -> &QDateTime; + #[rust_name = "insert_QDateTime"] + fn qset_insert(_: &mut QSet_QDateTime, _: &QDateTime); + #[rust_name = "len_QDateTime"] + fn qset_len(_: &QSet_QDateTime) -> usize; } } + +pub(crate) fn clone(s: &ffi::QSet_QDateTime) -> ffi::QSet_QDateTime { + ffi::clone_QDateTime(s) +} + +pub(crate) fn default() -> ffi::QSet_QDateTime { + ffi::default_QDateTime() +} + +pub(crate) fn drop(s: &mut ffi::QSet_QDateTime) { + ffi::drop_QDateTime(s); +} + +pub(crate) unsafe fn get_unchecked(s: &ffi::QSet_QDateTime, pos: usize) -> &ffi::QDateTime { + ffi::get_unchecked_QDateTime(s, pos) +} + +pub(crate) fn insert(s: &mut ffi::QSet_QDateTime, value: &ffi::QDateTime) { + ffi::insert_QDateTime(s, value); +} + +pub(crate) fn len(s: &ffi::QSet_QDateTime) -> usize { + ffi::len_QDateTime(s) +} diff --git a/crates/cxx-qt-lib/src/types/qset/qset_qstring.rs b/crates/cxx-qt-lib/src/types/qset/qset_qstring.rs index b215ea842..a6753255f 100644 --- a/crates/cxx-qt-lib/src/types/qset/qset_qstring.rs +++ b/crates/cxx-qt-lib/src/types/qset/qset_qstring.rs @@ -22,19 +22,43 @@ pub mod ffi { fn remove(self: &mut QSet_QString, _: &QString) -> bool; } - #[namespace = "rust::cxxqtlib1::qset_QString"] + #[namespace = "rust::cxxqtlib1"] unsafe extern "C++" { - #[rust_name = "clone"] - fn qset_clone_QString(_: &QSet_QString) -> QSet_QString; - #[rust_name = "default"] - fn qset_default_QString() -> QSet_QString; - #[rust_name = "drop"] - fn qset_drop_QString(_: &mut QSet_QString); - #[rust_name = "get_unchecked"] - unsafe fn qset_get_unchecked_QString(set: &QSet_QString, pos: usize) -> &QString; - #[rust_name = "insert"] - fn qset_insert_QString(_: &mut QSet_QString, _: &QString); - #[rust_name = "len"] - fn qset_len_QString(_: &QSet_QString) -> usize; + #[rust_name = "clone_QString"] + fn qset_clone(_: &QSet_QString) -> QSet_QString; + #[rust_name = "default_QString"] + fn qset_default() -> QSet_QString; + #[rust_name = "drop_QString"] + fn qset_drop(_: &mut QSet_QString); + #[rust_name = "get_unchecked_QString"] + unsafe fn qset_get_unchecked(set: &QSet_QString, pos: usize) -> &QString; + #[rust_name = "insert_QString"] + fn qset_insert(_: &mut QSet_QString, _: &QString); + #[rust_name = "len_QString"] + fn qset_len(_: &QSet_QString) -> usize; } } + +pub(crate) fn clone(s: &ffi::QSet_QString) -> ffi::QSet_QString { + ffi::clone_QString(s) +} + +pub(crate) fn default() -> ffi::QSet_QString { + ffi::default_QString() +} + +pub(crate) fn drop(s: &mut ffi::QSet_QString) { + ffi::drop_QString(s); +} + +pub(crate) unsafe fn get_unchecked(s: &ffi::QSet_QString, pos: usize) -> &ffi::QString { + ffi::get_unchecked_QString(s, pos) +} + +pub(crate) fn insert(s: &mut ffi::QSet_QString, value: &ffi::QString) { + ffi::insert_QString(s, value); +} + +pub(crate) fn len(s: &ffi::QSet_QString) -> usize { + ffi::len_QString(s) +} diff --git a/crates/cxx-qt-lib/src/types/qset/qset_qtime.rs b/crates/cxx-qt-lib/src/types/qset/qset_qtime.rs index 46d82f2f1..bfc0df616 100644 --- a/crates/cxx-qt-lib/src/types/qset/qset_qtime.rs +++ b/crates/cxx-qt-lib/src/types/qset/qset_qtime.rs @@ -22,19 +22,43 @@ pub mod ffi { fn remove(self: &mut QSet_QTime, _: &QTime) -> bool; } - #[namespace = "rust::cxxqtlib1::qset_QTime"] + #[namespace = "rust::cxxqtlib1"] unsafe extern "C++" { - #[rust_name = "clone"] - fn qset_clone_QTime(_: &QSet_QTime) -> QSet_QTime; - #[rust_name = "default"] - fn qset_default_QTime() -> QSet_QTime; - #[rust_name = "drop"] - fn qset_drop_QTime(_: &mut QSet_QTime); - #[rust_name = "get_unchecked"] - unsafe fn qset_get_unchecked_QTime(set: &QSet_QTime, pos: usize) -> &QTime; - #[rust_name = "insert"] - fn qset_insert_QTime(_: &mut QSet_QTime, _: &QTime); - #[rust_name = "len"] - fn qset_len_QTime(_: &QSet_QTime) -> usize; + #[rust_name = "clone_QTime"] + fn qset_clone(_: &QSet_QTime) -> QSet_QTime; + #[rust_name = "default_QTime"] + fn qset_default() -> QSet_QTime; + #[rust_name = "drop_QTime"] + fn qset_drop(_: &mut QSet_QTime); + #[rust_name = "get_unchecked_QTime"] + unsafe fn qset_get_unchecked(set: &QSet_QTime, pos: usize) -> &QTime; + #[rust_name = "insert_QTime"] + fn qset_insert(_: &mut QSet_QTime, _: &QTime); + #[rust_name = "len_QTime"] + fn qset_len(_: &QSet_QTime) -> usize; } } + +pub(crate) fn clone(s: &ffi::QSet_QTime) -> ffi::QSet_QTime { + ffi::clone_QTime(s) +} + +pub(crate) fn default() -> ffi::QSet_QTime { + ffi::default_QTime() +} + +pub(crate) fn drop(s: &mut ffi::QSet_QTime) { + ffi::drop_QTime(s); +} + +pub(crate) unsafe fn get_unchecked(s: &ffi::QSet_QTime, pos: usize) -> &ffi::QTime { + ffi::get_unchecked_QTime(s, pos) +} + +pub(crate) fn insert(s: &mut ffi::QSet_QTime, value: &ffi::QTime) { + ffi::insert_QTime(s, value); +} + +pub(crate) fn len(s: &ffi::QSet_QTime) -> usize { + ffi::len_QTime(s) +} diff --git a/crates/cxx-qt-lib/src/types/qset/qset_qurl.rs b/crates/cxx-qt-lib/src/types/qset/qset_qurl.rs index 2e0f38def..d92ed1700 100644 --- a/crates/cxx-qt-lib/src/types/qset/qset_qurl.rs +++ b/crates/cxx-qt-lib/src/types/qset/qset_qurl.rs @@ -22,19 +22,43 @@ pub mod ffi { fn remove(self: &mut QSet_QUrl, _: &QUrl) -> bool; } - #[namespace = "rust::cxxqtlib1::qset_QUrl"] + #[namespace = "rust::cxxqtlib1"] unsafe extern "C++" { - #[rust_name = "clone"] - fn qset_clone_QUrl(_: &QSet_QUrl) -> QSet_QUrl; - #[rust_name = "default"] - fn qset_default_QUrl() -> QSet_QUrl; - #[rust_name = "drop"] - fn qset_drop_QUrl(_: &mut QSet_QUrl); - #[rust_name = "get_unchecked"] - unsafe fn qset_get_unchecked_QUrl(set: &QSet_QUrl, pos: usize) -> &QUrl; - #[rust_name = "insert"] - fn qset_insert_QUrl(_: &mut QSet_QUrl, _: &QUrl); - #[rust_name = "len"] - fn qset_len_QUrl(_: &QSet_QUrl) -> usize; + #[rust_name = "clone_QUrl"] + fn qset_clone(_: &QSet_QUrl) -> QSet_QUrl; + #[rust_name = "default_QUrl"] + fn qset_default() -> QSet_QUrl; + #[rust_name = "drop_QUrl"] + fn qset_drop(_: &mut QSet_QUrl); + #[rust_name = "get_unchecked_QUrl"] + unsafe fn qset_get_unchecked(set: &QSet_QUrl, pos: usize) -> &QUrl; + #[rust_name = "insert_QUrl"] + fn qset_insert(_: &mut QSet_QUrl, _: &QUrl); + #[rust_name = "len_QUrl"] + fn qset_len(_: &QSet_QUrl) -> usize; } } + +pub(crate) fn clone(s: &ffi::QSet_QUrl) -> ffi::QSet_QUrl { + ffi::clone_QUrl(s) +} + +pub(crate) fn default() -> ffi::QSet_QUrl { + ffi::default_QUrl() +} + +pub(crate) fn drop(s: &mut ffi::QSet_QUrl) { + ffi::drop_QUrl(s); +} + +pub(crate) unsafe fn get_unchecked(s: &ffi::QSet_QUrl, pos: usize) -> &ffi::QUrl { + ffi::get_unchecked_QUrl(s, pos) +} + +pub(crate) fn insert(s: &mut ffi::QSet_QUrl, value: &ffi::QUrl) { + ffi::insert_QUrl(s, value); +} + +pub(crate) fn len(s: &ffi::QSet_QUrl) -> usize { + ffi::len_QUrl(s) +} diff --git a/crates/cxx-qt-lib/src/types/qset/qset_u16.rs b/crates/cxx-qt-lib/src/types/qset/qset_u16.rs index 588ebe9b5..980cddf82 100644 --- a/crates/cxx-qt-lib/src/types/qset/qset_u16.rs +++ b/crates/cxx-qt-lib/src/types/qset/qset_u16.rs @@ -19,20 +19,44 @@ pub mod ffi { fn remove(self: &mut QSet_u16, _: &u16) -> bool; } - #[namespace = "rust::cxxqtlib1::qset_u16"] + #[namespace = "rust::cxxqtlib1"] unsafe extern "C++" { - #[rust_name = "clone"] - fn qset_clone_u16(_: &QSet_u16) -> QSet_u16; - #[rust_name = "default"] - fn qset_default_u16() -> QSet_u16; - #[rust_name = "drop"] - fn qset_drop_u16(_: &mut QSet_u16); - #[rust_name = "get_unchecked"] + #[rust_name = "clone_u16"] + fn qset_clone(_: &QSet_u16) -> QSet_u16; + #[rust_name = "default_u16"] + fn qset_default() -> QSet_u16; + #[rust_name = "drop_u16"] + fn qset_drop(_: &mut QSet_u16); + #[rust_name = "get_unchecked_u16"] #[allow(clippy::needless_lifetimes)] - unsafe fn qset_get_unchecked_u16<'a>(set: &'a QSet_u16, pos: usize) -> &'a u16; - #[rust_name = "insert"] - fn qset_insert_u16(_: &mut QSet_u16, _: &u16); - #[rust_name = "len"] - fn qset_len_u16(_: &QSet_u16) -> usize; + unsafe fn qset_get_unchecked<'a>(set: &'a QSet_u16, pos: usize) -> &'a u16; + #[rust_name = "insert_u16"] + fn qset_insert(_: &mut QSet_u16, _: &u16); + #[rust_name = "len_u16"] + fn qset_len(_: &QSet_u16) -> usize; } } + +pub(crate) fn clone(s: &ffi::QSet_u16) -> ffi::QSet_u16 { + ffi::clone_u16(s) +} + +pub(crate) fn default() -> ffi::QSet_u16 { + ffi::default_u16() +} + +pub(crate) fn drop(s: &mut ffi::QSet_u16) { + ffi::drop_u16(s); +} + +pub(crate) unsafe fn get_unchecked(s: &ffi::QSet_u16, pos: usize) -> &u16 { + ffi::get_unchecked_u16(s, pos) +} + +pub(crate) fn insert(s: &mut ffi::QSet_u16, value: &u16) { + ffi::insert_u16(s, value); +} + +pub(crate) fn len(s: &ffi::QSet_u16) -> usize { + ffi::len_u16(s) +} diff --git a/crates/cxx-qt-lib/src/types/qset/qset_u32.rs b/crates/cxx-qt-lib/src/types/qset/qset_u32.rs index 649020e10..6aee4a9d5 100644 --- a/crates/cxx-qt-lib/src/types/qset/qset_u32.rs +++ b/crates/cxx-qt-lib/src/types/qset/qset_u32.rs @@ -19,20 +19,44 @@ pub mod ffi { fn remove(self: &mut QSet_u32, _: &u32) -> bool; } - #[namespace = "rust::cxxqtlib1::qset_u32"] + #[namespace = "rust::cxxqtlib1"] unsafe extern "C++" { - #[rust_name = "clone"] - fn qset_clone_u32(_: &QSet_u32) -> QSet_u32; - #[rust_name = "default"] - fn qset_default_u32() -> QSet_u32; - #[rust_name = "drop"] - fn qset_drop_u32(_: &mut QSet_u32); - #[rust_name = "get_unchecked"] + #[rust_name = "clone_u32"] + fn qset_clone(_: &QSet_u32) -> QSet_u32; + #[rust_name = "default_u32"] + fn qset_default() -> QSet_u32; + #[rust_name = "drop_u32"] + fn qset_drop(_: &mut QSet_u32); + #[rust_name = "get_unchecked_u32"] #[allow(clippy::needless_lifetimes)] - unsafe fn qset_get_unchecked_u32<'a>(set: &'a QSet_u32, pos: usize) -> &'a u32; - #[rust_name = "insert"] - fn qset_insert_u32(_: &mut QSet_u32, _: &u32); - #[rust_name = "len"] - fn qset_len_u32(_: &QSet_u32) -> usize; + unsafe fn qset_get_unchecked<'a>(set: &'a QSet_u32, pos: usize) -> &'a u32; + #[rust_name = "insert_u32"] + fn qset_insert(_: &mut QSet_u32, _: &u32); + #[rust_name = "len_u32"] + fn qset_len(_: &QSet_u32) -> usize; } } + +pub(crate) fn clone(s: &ffi::QSet_u32) -> ffi::QSet_u32 { + ffi::clone_u32(s) +} + +pub(crate) fn default() -> ffi::QSet_u32 { + ffi::default_u32() +} + +pub(crate) fn drop(s: &mut ffi::QSet_u32) { + ffi::drop_u32(s); +} + +pub(crate) unsafe fn get_unchecked(s: &ffi::QSet_u32, pos: usize) -> &u32 { + ffi::get_unchecked_u32(s, pos) +} + +pub(crate) fn insert(s: &mut ffi::QSet_u32, value: &u32) { + ffi::insert_u32(s, value); +} + +pub(crate) fn len(s: &ffi::QSet_u32) -> usize { + ffi::len_u32(s) +} diff --git a/crates/cxx-qt-lib/src/types/qset/qset_u8.rs b/crates/cxx-qt-lib/src/types/qset/qset_u8.rs index b69be628d..806565421 100644 --- a/crates/cxx-qt-lib/src/types/qset/qset_u8.rs +++ b/crates/cxx-qt-lib/src/types/qset/qset_u8.rs @@ -19,20 +19,44 @@ pub mod ffi { fn remove(self: &mut QSet_u8, _: &u8) -> bool; } - #[namespace = "rust::cxxqtlib1::qset_u8"] + #[namespace = "rust::cxxqtlib1"] unsafe extern "C++" { - #[rust_name = "clone"] - fn qset_clone_u8(_: &QSet_u8) -> QSet_u8; - #[rust_name = "default"] - fn qset_default_u8() -> QSet_u8; - #[rust_name = "drop"] - fn qset_drop_u8(_: &mut QSet_u8); - #[rust_name = "get_unchecked"] + #[rust_name = "clone_u8"] + fn qset_clone(_: &QSet_u8) -> QSet_u8; + #[rust_name = "default_u8"] + fn qset_default() -> QSet_u8; + #[rust_name = "drop_u8"] + fn qset_drop(_: &mut QSet_u8); + #[rust_name = "get_unchecked_u8"] #[allow(clippy::needless_lifetimes)] - unsafe fn qset_get_unchecked_u8<'a>(set: &'a QSet_u8, pos: usize) -> &'a u8; - #[rust_name = "insert"] - fn qset_insert_u8(_: &mut QSet_u8, _: &u8); - #[rust_name = "len"] - fn qset_len_u8(_: &QSet_u8) -> usize; + unsafe fn qset_get_unchecked<'a>(set: &'a QSet_u8, pos: usize) -> &'a u8; + #[rust_name = "insert_u8"] + fn qset_insert(_: &mut QSet_u8, _: &u8); + #[rust_name = "len_u8"] + fn qset_len(_: &QSet_u8) -> usize; } } + +pub(crate) fn clone(s: &ffi::QSet_u8) -> ffi::QSet_u8 { + ffi::clone_u8(s) +} + +pub(crate) fn default() -> ffi::QSet_u8 { + ffi::default_u8() +} + +pub(crate) fn drop(s: &mut ffi::QSet_u8) { + ffi::drop_u8(s); +} + +pub(crate) unsafe fn get_unchecked(s: &ffi::QSet_u8, pos: usize) -> &u8 { + ffi::get_unchecked_u8(s, pos) +} + +pub(crate) fn insert(s: &mut ffi::QSet_u8, value: &u8) { + ffi::insert_u8(s, value); +} + +pub(crate) fn len(s: &ffi::QSet_u8) -> usize { + ffi::len_u8(s) +} From ea2c3336ca10e5cb83bc4d6e444a0d3b5bf6eeeb Mon Sep 17 00:00:00 2001 From: Andrew Hayzen Date: Thu, 24 Nov 2022 11:02:32 +0000 Subject: [PATCH 4/4] examples: add containers page for QSet and later hash, vector --- examples/qml_features/cpp/main.cpp | 3 + examples/qml_features/qml/main.qml | 4 ++ .../qml_features/qml/pages/ContainersPage.qml | 60 +++++++++++++++++++ examples/qml_features/qml/qml.qrc | 1 + examples/qml_features/rust/build.rs | 1 + examples/qml_features/rust/src/containers.rs | 42 +++++++++++++ examples/qml_features/rust/src/lib.rs | 1 + 7 files changed, 112 insertions(+) create mode 100644 examples/qml_features/qml/pages/ContainersPage.qml create mode 100644 examples/qml_features/rust/src/containers.rs diff --git a/examples/qml_features/cpp/main.cpp b/examples/qml_features/cpp/main.cpp index 335773a58..aa6e484e7 100644 --- a/examples/qml_features/cpp/main.cpp +++ b/examples/qml_features/cpp/main.cpp @@ -10,6 +10,7 @@ #include "cxx-qt-gen/custom_base_class.cxxqt.h" #include "cxx-qt-gen/multiple_qobjects.cxxqt.h" +#include "cxx-qt-gen/rust_containers.cxxqt.h" #include "cxx-qt-gen/rust_invokables.cxxqt.h" #include "cxx-qt-gen/rust_properties.cxxqt.h" #include "cxx-qt-gen/rust_signals.cxxqt.h" @@ -35,6 +36,8 @@ main(int argc, char* argv[]) }, Qt::QueuedConnection); + qmlRegisterType( + "com.kdab.cxx_qt.demo", 1, 0, "RustContainers"); qmlRegisterType( "com.kdab.cxx_qt.demo", 1, 0, "CustomBaseClass"); qmlRegisterType("com.kdab.cxx_qt.demo", 1, 0, "FirstObject"); diff --git a/examples/qml_features/qml/main.qml b/examples/qml_features/qml/main.qml index d25c5a161..016d635fa 100644 --- a/examples/qml_features/qml/main.qml +++ b/examples/qml_features/qml/main.qml @@ -95,6 +95,10 @@ ApplicationWindow { name: "Types" source: "qrc:/pages/TypesPage.qml" } + ListElement { + name: "Containers" + source: "qrc:/pages/ContainersPage.qml" + } ListElement { name: "Multiple QObjects" source: "qrc:/pages/MultipleQObjectsPage.qml" diff --git a/examples/qml_features/qml/pages/ContainersPage.qml b/examples/qml_features/qml/pages/ContainersPage.qml new file mode 100644 index 000000000..1e708c298 --- /dev/null +++ b/examples/qml_features/qml/pages/ContainersPage.qml @@ -0,0 +1,60 @@ +// SPDX-FileCopyrightText: 2022 Klarälvdalens Datakonsult AB, a KDAB Group company +// SPDX-FileContributor: Andrew Hayzen +// +// SPDX-License-Identifier: MIT OR Apache-2.0 +import QtQuick 2.12 +import QtQuick.Controls 2.12 +import QtQuick.Layouts 1.12 + +import com.kdab.cxx_qt.demo 1.0 + +Page { + header: ToolBar { + RowLayout { + anchors.fill: parent + + ToolButton { + text: qsTr("Insert") + + onClicked: rustContainers.insert(spinBox.value) + } + + Item { + Layout.fillWidth: true + } + } + } + + RustContainers { + id: rustContainers + } + + ColumnLayout { + anchors.left: parent.left + anchors.right: parent.right + anchors.verticalCenter: parent.verticalCenter + + Label { + Layout.fillWidth: true + horizontalAlignment: Text.AlignHCenter + text: qsTr("Container types can be used from Rust to QML as normal.") + wrapMode: Text.Wrap + } + + Label { + Layout.fillWidth: true + horizontalAlignment: Text.AlignHCenter + text: qsTr("QSet values: %1").arg(rustContainers.stringSet) + wrapMode: Text.Wrap + visible: rustContainers.stringSet !== "" + } + + SpinBox { + id: spinBox + Layout.alignment: Qt.AlignHCenter + from: 0 + to: 100 + value: 10 + } + } +} diff --git a/examples/qml_features/qml/qml.qrc b/examples/qml_features/qml/qml.qrc index c3b0adbab..2f977f91b 100644 --- a/examples/qml_features/qml/qml.qrc +++ b/examples/qml_features/qml/qml.qrc @@ -9,6 +9,7 @@ SPDX-License-Identifier: MIT OR Apache-2.0 main.qml + pages/ContainersPage.qml pages/CustomBaseClassPage.qml pages/InvokablesPage.qml pages/MultipleQObjectsPage.qml diff --git a/examples/qml_features/rust/build.rs b/examples/qml_features/rust/build.rs index 88ceb5147..b6287f95d 100644 --- a/examples/qml_features/rust/build.rs +++ b/examples/qml_features/rust/build.rs @@ -12,6 +12,7 @@ fn main() { .cc_builder(|cc| { cc.include("../cpp"); }) + .file("src/containers.rs") .file("src/custom_base_class.rs") .file("src/invokables.rs") .file("src/multiple_qobjects.rs") diff --git a/examples/qml_features/rust/src/containers.rs b/examples/qml_features/rust/src/containers.rs new file mode 100644 index 000000000..f3a575675 --- /dev/null +++ b/examples/qml_features/rust/src/containers.rs @@ -0,0 +1,42 @@ +// SPDX-FileCopyrightText: 2022 Klarälvdalens Datakonsult AB, a KDAB Group company +// SPDX-FileContributor: Andrew Hayzen +// +// SPDX-License-Identifier: MIT OR Apache-2.0 + +#[cxx_qt::bridge(cxx_file_stem = "rust_containers")] +mod ffi { + unsafe extern "C++" { + include!("cxx-qt-lib/qset.h"); + type QSet_i32 = cxx_qt_lib::QSet; + include!("cxx-qt-lib/qstring.h"); + type QString = cxx_qt_lib::QString; + } + + #[cxx_qt::qobject] + #[derive(Default)] + pub struct RustContainers { + #[qproperty] + string_set: QString, + + set: QSet_i32, + } + + impl qobject::RustContainers { + #[qinvokable] + pub fn insert(mut self: Pin<&mut Self>, value: i32) { + unsafe { + self.as_mut().rust_mut().set.insert(value); + } + + let set_items = self + .as_ref() + .set() + .iter() + .map(|value| value.to_string()) + .collect::>() + .join(", "); + + self.set_string_set(QString::from(&set_items)); + } + } +} diff --git a/examples/qml_features/rust/src/lib.rs b/examples/qml_features/rust/src/lib.rs index 5d29d6f0e..dbcfd4024 100644 --- a/examples/qml_features/rust/src/lib.rs +++ b/examples/qml_features/rust/src/lib.rs @@ -4,6 +4,7 @@ // // SPDX-License-Identifier: MIT OR Apache-2.0 +mod containers; mod custom_base_class; mod invokables; mod multiple_qobjects;