Add serde support for cxx-qt-lib using proxy types and deriving

CHANGELOG.md

@@ -19,7 +19,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- `Deref` and `DerefMut` implementations to `QList` for `QStringList`, `QPolygon`, and `QPolygonF`.
+- `QDate::format`, `QDateTime::format`, and `QTime::format` to create a `QString` with a specific `DateFormat`.
 - `QDateTime::from_string` to parse `QDateTime` from a `QString`.
+- `QSet::reserve` to reserve capacity up-front.
 - Support for further types: `QUuid`
 - New example: Basic greeter app
 - Support for further types: `qreal`, `qint64`, `qintptr`, `qsizetype`, `quint64`, `quintptr`
@@ -30,6 +33,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Add pure virtual function specified through the `#[cxx_pure]` attribute
 - Add wrappers for up and down casting, for all types which inherit from QObject, available for &T, &mut T and Pin<&mut T>
 - Support for `QMessageLogContext` and sending log messages to the Qt message handler.
+- Serde support for further types: `QByteArray`, `QColor`, `QDate`, `QDateTime`, `QFont`, `QLine`, `QLineF`, `QList`, `QMargins`, `QMarginsF`, `QPoint`, `QPointF`, `QPolygon`, `QPolygonF`, `QRect`, `QRectF`, `QSet`, `QSize`, `QSizeF`, `QStringList`, `QVector`, `QVector2D`, `QVector3D`, `QVector4D`, `QTime`, `QUrl`, `QUuid`
 
 ### Removed
 
@@ -144,7 +148,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Do not use -bundle otherwise CMake builds are missing qt-static-initalizers (note this is broken in rustc 1.69)
 - Do not import `Pin` in hidden module as invokables are outside now, resolving IDE integration
-- Rust always links against a non-debug Windows runtime with *-msvc targets, so we need to link to MultiThreadedDLL
+- Rust always links against a non-debug Windows runtime with \*-msvc targets, so we need to link to MultiThreadedDLL
 
 ### Removed
 

crates/cxx-qt-lib/Cargo.toml

@@ -42,6 +42,9 @@ image-v0-25 = { version = "0.25", optional = true, package = "image", default-fe
 cxx-qt-build.workspace = true
 qt-build-utils.workspace = true
 
+[dev-dependencies]
+serde_json = "1.0.135"
+
 [features]
 full = ["qt_full", "serde", "url", "uuid", "time", "rgb", "http", "chrono", "bytes", "image-v0-24", "image-v0-25"]
 default = []

crates/cxx-qt-lib/include/core/qset/qset_private.h

@@ -58,6 +58,19 @@ qsetLen(const QSet<T>& s) noexcept
   return static_cast<::rust::isize>(s.size());
 }
 
+template<typename T>
+void
+qsetReserve(QSet<T>& s, ::rust::isize size) noexcept
+{
+  Q_ASSERT(size >= 0);
+  // Qt 5 has an int Qt 6 has a qsizetype
+#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
+  s.reserve(static_cast<qsizetype>(size));
+#else
+  s.reserve(static_cast<int>(size));
+#endif
+}
+
 }
 }
 }

crates/cxx-qt-lib/include/core/quuid.h

@@ -10,6 +10,7 @@
 
 #include "rust/cxx.h"
 
+using QUuidStringFormat = QUuid::StringFormat;
 using QUuidVariant = QUuid::Variant;
 using QUuidVersion = QUuid::Version;
 
@@ -24,9 +25,6 @@ quuidCreateUuid();
 QUuid
 quuidCreateUuidV5(const QUuid& ns, ::rust::Slice<const ::std::uint8_t> slice);
 
-QString
-quuidToString(const QUuid& uuid);
-
 QUuid
 quuidFromString(const QString& string);
 

crates/cxx-qt-lib/src/core/qbytearray.rs

@@ -321,6 +321,54 @@ impl QByteArray {
     }
 }
 
+#[cfg(feature = "serde")]
+impl serde::Serialize for QByteArray {
+    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        serializer.serialize_bytes(self.as_slice())
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QByteArray {
+    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        use serde::de::{Error as DeError, SeqAccess, Visitor};
+
+        struct BytesVisitor;
+
+        impl<'de> Visitor<'de> for BytesVisitor {
+            type Value = QByteArray;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                formatter.write_str("an array of bytes")
+            }
+
+            fn visit_bytes<E: DeError>(self, v: &[u8]) -> Result<Self::Value, E> {
+                Ok(Self::Value::from(v))
+            }
+
+            fn visit_str<E: DeError>(self, v: &str) -> Result<Self::Value, E> {
+                Ok(Self::Value::from(v))
+            }
+
+            fn visit_seq<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Self::Value, A::Error> {
+                let mut values = Self::Value::default();
+                if let Some(size_hint) = seq.size_hint() {
+                    if size_hint != 0 && size_hint <= isize::MAX as usize {
+                        values.reserve(size_hint as isize);
+                    }
+                }
+                while let Some(value) = seq.next_element()? {
+                    values.append(value);
+                }
+                Ok(values)
+            }
+        }
+
+        let visitor = BytesVisitor;
+        deserializer.deserialize_byte_buf(visitor)
+    }
+}
+
 // Safety:
 //
 // Static checks on the C++ side to ensure the size is the same.
@@ -334,6 +382,13 @@ mod tests {
     #[cfg(feature = "bytes")]
     use super::*;
 
+    #[cfg(feature = "serde")]
+    #[test]
+    fn qbytearray_serde() {
+        let qbytearray = QByteArray::from("KDAB");
+        assert_eq!(crate::serde_impl::roundtrip(&qbytearray), qbytearray)
+    }
+
     #[cfg(feature = "bytes")]
     #[test]
     fn test_bytes() {

crates/cxx-qt-lib/src/core/qdate.rs

@@ -176,7 +176,7 @@ impl QDate {
         Self { jd }
     }
 
-    /// Returns the QTime represented by the string, using the format given, or None if the string cannot be parsed.
+    /// Returns the QDate represented by the string, using the format given, or None if the string cannot be parsed.
     pub fn from_string(string: &ffi::QString, format: &ffi::QString) -> Option<Self> {
         let date = ffi::qdate_from_string(string, format);
         if date.is_valid() {
@@ -186,7 +186,7 @@ impl QDate {
         }
     }
 
-    /// Returns the time represented in the string as a QTime using the format given, or None if this is not possible.
+    /// Returns the time represented in the string as a QDate using the format given, or None if this is not possible.
     pub fn from_string_enum(string: &ffi::QString, format: ffi::DateFormat) -> Option<Self> {
         let date = ffi::qdate_from_string_enum(string, format);
         if date.is_valid() {
@@ -290,6 +290,13 @@ mod test {
         assert_eq!(QDate::from(naive), qdate);
     }
 
+    #[cfg(feature = "serde")]
+    #[test]
+    fn qdate_serde() {
+        let qdate = QDate::new(2023, 1, 1);
+        assert_eq!(crate::serde_impl::roundtrip(&qdate), qdate);
+    }
+
     #[cfg(feature = "chrono")]
     #[test]
     fn qdate_to_chrono_naive() {

crates/cxx-qt-lib/src/core/qdatetime.rs

@@ -195,6 +195,7 @@ mod ffi {
         fn qdatetimeTimeZone(datetime: &QDateTime) -> UniquePtr<QTimeZone>;
         #[rust_name = "qdatetime_settimezone"]
         fn qdatetimeSetTimeZone(datetime: &mut QDateTime, time_zone: &QTimeZone);
+        #[doc(hidden)]
         #[rust_name = "qdatetime_from_string"]
         fn qdatetimeFromQString(string: &QString, format: DateFormat) -> QDateTime;
     }
@@ -514,6 +515,17 @@ mod test {
         assert_eq!(qdatetime_b.cmp(&qdatetime_a), Ordering::Greater);
         assert_eq!(qdatetime_a.cmp(&qdatetime_a), Ordering::Equal);
     }
+
+    #[cfg(feature = "serde")]
+    #[test]
+    fn qdatetime_serde() {
+        let qdatetime = QDateTime::from_date_and_time_time_zone(
+            &QDate::new(2023, 1, 1),
+            &QTime::new(1, 1, 1, 1),
+            &ffi::QTimeZone::utc(),
+        );
+        assert_eq!(crate::serde_impl::roundtrip(&qdatetime), qdatetime);
+    }
 }
 
 #[cfg(test)]

crates/cxx-qt-lib/src/core/qline.rs

@@ -98,8 +98,12 @@ mod ffi {
     }
 }
 
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
 /// The QLine class provides a two-dimensional vector using integer precision
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[repr(C)]
 pub struct QLine {
     pt1: QPoint,

crates/cxx-qt-lib/src/core/qlinef.rs

@@ -131,8 +131,12 @@ mod ffi {
     }
 }
 
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
 /// The QLineF class provides a two-dimensional vector using floating point precision.
 #[derive(Debug, Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[repr(C)]
 pub struct QLineF {
     pt1: QPointF,

crates/cxx-qt-lib/src/core/qlist/mod.rs

@@ -400,4 +400,11 @@ mod test {
         let qlist = QList::<u8>::from(array);
         assert_eq!(Vec::from(&qlist), array);
     }
+
+    #[cfg(feature = "serde")]
+    #[test]
+    fn qlist_serde() {
+        let qlist = QList::<u8>::from([0, 1, 2]);
+        assert_eq!(crate::serde_impl::roundtrip(&qlist), qlist);
+    }
 }

crates/cxx-qt-lib/src/core/qmargins.rs

@@ -96,8 +96,12 @@ mod ffi {
     }
 }
 
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
 /// The QMargins class defines the four margins of a rectangle.
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[repr(C)]
 pub struct QMargins {
     left: i32,

crates/cxx-qt-lib/src/core/qmarginsf.rs

@@ -92,8 +92,12 @@ mod ffi {
     }
 }
 
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
 /// The QMarginsF class defines the four margins of a rectangle.
 #[derive(Debug, Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[repr(C)]
 pub struct QMarginsF {
     left: f64,

crates/cxx-qt-lib/src/core/qpoint.rs

@@ -93,8 +93,12 @@ mod ffi {
     }
 }
 
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
 /// The QPoint struct defines a point in the plane using integer precision.
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[repr(C)]
 pub struct QPoint {
     x: i32,

crates/cxx-qt-lib/src/core/qpointf.rs

@@ -86,9 +86,12 @@ mod ffi {
         fn operatorDiv(a: f64, b: &QPointF) -> QPointF;
     }
 }
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
 
 /// The QPointF struct defines a point in the plane using floating point precision.
 #[derive(Debug, Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[repr(C)]
 pub struct QPointF {
     x: f64,

crates/cxx-qt-lib/src/core/qrect.rs

@@ -268,8 +268,12 @@ mod ffi {
     }
 }
 
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
 /// The QRect struct defines a rectangle in the plane using integer precision.
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[repr(C)]
 pub struct QRect {
     // Note that Qt stores QRect as two points rather than a point and size (which QRectF is)

crates/cxx-qt-lib/src/core/qrectf.rs

@@ -269,9 +269,12 @@ mod ffi {
         fn operatorMinus(a: &QRectF, b: &QMarginsF) -> QRectF;
     }
 }
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
 
 /// The QRectF struct defines a rectangle in the plane using floating point precision.
 #[derive(Debug, Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[repr(C)]
 pub struct QRectF {
     xp: f64,

crates/cxx-qt-lib/src/core/qset/generate.sh

@@ -72,6 +72,8 @@ pub mod ffi {
         fn qsetInsert(_: &mut QSet_$1, _: &$1);
         #[rust_name = "len_$1"]
         fn qsetLen(_: &QSet_$1) -> isize;
+        #[rust_name = "reserve_$1"]
+        fn qsetReserve(_: &mut QSet_$1, size: isize);
     }
 }
 
@@ -98,6 +100,10 @@ pub(crate) fn insert(s: &mut ffi::QSet_$1, value: &$1) {
 pub(crate) fn len(s: &ffi::QSet_$1) -> isize {
     ffi::len_$1(s)
 }
+
+pub(crate) fn reserve(s: &mut ffi::QSet_$1, size: isize) {
+  ffi::reserve_$1(s, size);
+}
 EOF
     rustfmt "$SCRIPTPATH/qset_$1.rs"
 }
@@ -148,6 +154,8 @@ pub mod ffi {
         fn qsetInsert(_: &mut QSet_$1, _: &$1);
         #[rust_name = "len_$1"]
         fn qsetLen(_: &QSet_$1) -> isize;
+        #[rust_name = "reserve_$1"]
+        fn qsetReserve(_: &mut QSet_$1, size: isize);
     }
 }
 
@@ -174,6 +182,10 @@ pub(crate) fn insert(s: &mut ffi::QSet_$1, value: &ffi::$1) {
 pub(crate) fn len(s: &ffi::QSet_$1) -> isize {
     ffi::len_$1(s)
 }
+
+pub(crate) fn reserve(s: &mut ffi::QSet_$1, size: isize) {
+  ffi::reserve_$1(s, size);
+}
 EOF
     rustfmt "$SCRIPTPATH/qset_$2.rs"
 }