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

CHANGELOG.md

@@ -21,6 +21,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - `QDateTime::from_string` to parse `QDateTime` from a `QString`.
 - Support for further types: `QUuid`
+- Serde support for further types: `QByteArray`, `QColor`, `QDate`, `QDateTime`, `QLine`, `QLineF`, `QList`, `QMargins`, `QMarginsF`, `QPoint`, `QPointF`, `QPolygon`, `QPolygonF`, `QRect`, `QRectF`, `QSet`, `QSize`, `QSizeF`,  `QStringList`, `QVector`, `QVector2D`, `QVector3D`, `QVector4D`, `QTime`, `QUrl`, `QUuid`
 
 ### Fixed
 

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/qdate.h

@@ -30,6 +30,8 @@ bool
 qdateIsLeapYear(::std::int32_t year);
 QString
 qdateToFormat(const QDate& date, const QString& format);
+QString
+qdateToFormat(const QDate& date, Qt::DateFormat format);
 
 }
 }

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

@@ -70,5 +70,7 @@ void
 qdatetimeSetTimeZone(QDateTime& datetime, const QTimeZone& timeZone);
 QDateTime
 qdatetimeFromQString(const QString& string, Qt::DateFormat format);
+QString
+qdatetimeToFormat(const QDateTime& datetime, Qt::DateFormat format);
 }
 }

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/qtime.h

@@ -26,6 +26,8 @@ QTime
 qtimeFromString(const QString& string, const QString& format);
 QTime
 qtimeFromString(const QString& string, Qt::DateFormat format);
+QString
+qtimeToFormat(const QTime& time, Qt::DateFormat format);
 // In Qt 5 t is const-ref, in Qt 6 it is value
 ::std::int32_t
 qtimeSecsTo(const QTime& time, QTime t);

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.cpp

@@ -64,5 +64,11 @@ qdateToFormat(const QDate& date, const QString& format)
   return date.toString(format);
 }
 
+QString
+qdateToFormat(const QDate& date, Qt::DateFormat format)
+{
+  return date.toString(format);
+}
+
 }
 }

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

@@ -102,6 +102,10 @@ mod ffi {
         #[doc(hidden)]
         #[rust_name = "qdate_to_format"]
         fn qdateToFormat(date: &QDate, format: &QString) -> QString;
+
+        #[doc(hidden)]
+        #[rust_name = "qdate_to_format_enum"]
+        fn qdateToFormat(date: &QDate, format: DateFormat) -> QString;
     }
 
     #[namespace = "rust::cxxqtlib1"]
@@ -176,7 +180,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 +190,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() {
@@ -196,6 +200,11 @@ impl QDate {
         }
     }
 
+    /// Returns the QDate as a string in the format given.
+    pub fn to_format(&self, format: ffi::DateFormat) -> ffi::QString {
+        ffi::qdate_to_format_enum(self, format)
+    }
+
     /// Returns true if the specified year is a leap year in the Gregorian calendar; otherwise returns false.
     pub fn is_leap_year(year: i32) -> bool {
         ffi::qdate_is_leap_year(year)
@@ -290,6 +299,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.cpp

@@ -160,5 +160,11 @@ qdatetimeFromQString(const QString& string, const Qt::DateFormat format)
   return QDateTime::fromString(string, format);
 }
 
+QString
+qdatetimeToFormat(const QDateTime& datetime, Qt::DateFormat format)
+{
+  return datetime.toString(format);
+}
+
 }
 }

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

@@ -168,10 +168,15 @@ 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;
+        #[doc(hidden)]
+        #[rust_name = "qdatetime_to_format"]
+        fn qdatetimeToFormat(datetime: &QDateTime, format: DateFormat) -> QString;
     }
 
     #[namespace = "rust::cxxqtlib1"]
@@ -311,6 +316,11 @@ impl QDateTime {
         }
     }
 
+    /// Returns the datetime as a string in the format given.
+    pub fn to_format(&self, format: ffi::DateFormat) -> ffi::QString {
+        ffi::qdatetime_to_format(self, format)
+    }
+
     /// Returns the number of milliseconds from this datetime to the other datetime.
     /// If the other datetime is earlier than this datetime, the value returned is negative.
     pub fn msecs_to(&self, other: &Self) -> i64 {
@@ -545,6 +555,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,