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

CHANGELOG.md

@@ -19,8 +19,12 @@ 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`
+- 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`
 
 ### Fixed
 
@@ -121,7 +125,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

@@ -36,6 +36,9 @@ serde = { version = "1", features=["derive"], optional = true }
 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"]
 default = []

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

@@ -67,6 +67,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/include/gui/qpolygon.h

@@ -6,6 +6,8 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 #pragma once
 
+#include <QtCore/QPoint>
+#include <QtCore/QVector>
 #include <QtGui/QPolygon>
 
 #include "rust/cxx.h"
@@ -19,3 +21,14 @@ struct IsRelocatable<QPolygon> : ::std::true_type
 {};
 
 } // namespace rust
+
+namespace rust {
+namespace cxxqtlib1 {
+
+const QVector<QPoint>&
+qpolygonAsQVectorQPointRef(const QPolygon& shape);
+QVector<QPoint>&
+qpolygonAsQVectorQPointRef(QPolygon& shape);
+
+}
+}

crates/cxx-qt-lib/include/gui/qpolygonf.h

@@ -6,6 +6,8 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 #pragma once
 
+#include <QtCore/QPointF>
+#include <QtCore/QVector>
 #include <QtGui/QPolygonF>
 
 #include "rust/cxx.h"
@@ -19,3 +21,14 @@ struct IsRelocatable<QPolygonF> : ::std::true_type
 {};
 
 } // namespace rust
+
+namespace rust {
+namespace cxxqtlib1 {
+
+const QVector<QPointF>&
+qpolygonfAsQVectorQPointFRef(const QPolygonF& shape);
+QVector<QPointF>&
+qpolygonfAsQVectorQPointFRef(QPolygonF& shape);
+
+}
+}

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

@@ -320,6 +320,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.
@@ -333,6 +381,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

@@ -142,7 +142,7 @@ impl fmt::Display for QDate {
 
 impl fmt::Debug for QDate {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{self}")
+        write!(f, "{}", ffi::qdate_to_qstring(self))
     }
 }
 
@@ -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

@@ -40,6 +40,10 @@ mod ffi {
         /// Returns the date part of the datetime.
         fn date(self: &QDateTime) -> QDate;
 
+        /// Returns the datetime as a string. The format parameter determines the format of the string.
+        #[rust_name = "format_enum"]
+        fn toString(self: &QDateTime, format: DateFormat) -> QString;
+
         /// Returns if this datetime falls in Daylight-Saving Time.
         #[rust_name = "is_daylight_time"]
         fn isDaylightTime(self: &QDateTime) -> bool;
@@ -168,8 +172,10 @@ mod ffi {
         #[doc(hidden)]
         #[rust_name = "qdatetime_to_secs_since_epoch"]
         fn qdatetimeToSecsSinceEpoch(datetime: &QDateTime) -> i64;
+        #[doc(hidden)]
         #[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;
     }
@@ -545,6 +551,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

@@ -75,6 +75,15 @@ where
 
 impl<T> Eq for QList<T> where T: QListElement + Eq {}
 
+impl<T> std::fmt::Debug for QList<T>
+where
+    T: QListElement + std::fmt::Debug,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        f.debug_list().entries(self.iter()).finish()
+    }
+}
+
 impl<T> QList<T>
 where
     T: QListElement,
@@ -390,4 +399,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,