Implement FromIterator for QList, QSet, and QVector (#1269)

* cxx-qt-lib: implement FromIterator for QList

* cxx-qt-lib: implement FromIterator for QSet

* cxx-qt-lib: implement FromIterator for QVector

* cxx-qt-lib: reserve_usize helper functions

* cxx-qt-lib: use isize::MAX if reserve is called with excessive value

Author: jnbooth

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

@@ -161,6 +161,28 @@ where
     pub fn reserve(&mut self, size: isize) {
         T::reserve(self, size);
     }
+
+    /// Helper function for handling Rust values.
+    pub(crate) fn reserve_usize(&mut self, size: usize) {
+        if size != 0 {
+            T::reserve(self, isize::try_from(size).unwrap_or(isize::MAX));
+        }
+    }
+}
+
+impl<T> QList<T>
+where
+    T: QListElement + ExternType<Kind = cxx::kind::Trivial>,
+{
+    /// Inserts value at the end of the list.
+    pub fn append(&mut self, value: T) {
+        T::append(self, value);
+    }
+
+    /// Inserts item value into the list at the given position.
+    pub fn insert(&mut self, pos: isize, value: T) {
+        T::insert(self, pos, value);
+    }
 }
 
 impl<T> From<&QList<T>> for Vec<T>
@@ -188,26 +210,59 @@ where
     /// The original slice can still be used after constructing the QList.
     fn from(vec: S) -> Self {
         let mut qlist = Self::default();
-        qlist.reserve(vec.as_ref().len().try_into().unwrap());
+        qlist.reserve_usize(vec.as_ref().len());
         for element in vec.as_ref() {
             qlist.append_clone(element);
         }
         qlist
     }
 }
 
-impl<T> QList<T>
+impl<'a, T> Extend<&'a T> for QList<T>
+where
+    T: QListElement,
+{
+    fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I) {
+        let iter = iter.into_iter();
+        self.reserve_usize(iter.size_hint().0);
+        for element in iter {
+            self.append_clone(element);
+        }
+    }
+}
+
+impl<T> Extend<T> for QList<T>
 where
     T: QListElement + ExternType<Kind = cxx::kind::Trivial>,
 {
-    /// Inserts value at the end of the list.
-    pub fn append(&mut self, value: T) {
-        T::append(self, value);
+    fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
+        let iter = iter.into_iter();
+        self.reserve_usize(iter.size_hint().0);
+        for element in iter {
+            self.append(element);
+        }
     }
+}
 
-    /// Inserts item value into the list at the given position.
-    pub fn insert(&mut self, pos: isize, value: T) {
-        T::insert(self, pos, value);
+impl<'a, T> FromIterator<&'a T> for QList<T>
+where
+    T: QListElement,
+{
+    fn from_iter<I: IntoIterator<Item = &'a T>>(iter: I) -> Self {
+        let mut qlist = Self::default();
+        qlist.extend(iter);
+        qlist
+    }
+}
+
+impl<T> FromIterator<T> for QList<T>
+where
+    T: QListElement + ExternType<Kind = cxx::kind::Trivial>,
+{
+    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
+        let mut qlist = Self::default();
+        qlist.extend(iter);
+        qlist
     }
 }
 

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

@@ -127,6 +127,13 @@ where
     pub fn reserve(&mut self, size: isize) {
         T::reserve(self, size);
     }
+
+    /// Helper function for handling Rust values.
+    pub(crate) fn reserve_usize(&mut self, size: usize) {
+        if size != 0 {
+            T::reserve(self, isize::try_from(size).unwrap_or(isize::MAX));
+        }
+    }
 }
 
 impl<T> QSet<T>
@@ -140,6 +147,54 @@ where
     }
 }
 
+impl<'a, T> Extend<&'a T> for QSet<T>
+where
+    T: QSetElement,
+{
+    fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I) {
+        let iter = iter.into_iter();
+        self.reserve_usize(iter.size_hint().0);
+        for element in iter {
+            self.insert_clone(element);
+        }
+    }
+}
+
+impl<T> Extend<T> for QSet<T>
+where
+    T: QSetElement + ExternType<Kind = cxx::kind::Trivial>,
+{
+    fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
+        let iter = iter.into_iter();
+        self.reserve_usize(iter.size_hint().0);
+        for element in iter {
+            self.insert(element);
+        }
+    }
+}
+
+impl<'a, T> FromIterator<&'a T> for QSet<T>
+where
+    T: QSetElement,
+{
+    fn from_iter<I: IntoIterator<Item = &'a T>>(iter: I) -> Self {
+        let mut qset = Self::default();
+        qset.extend(iter);
+        qset
+    }
+}
+
+impl<T> FromIterator<T> for QSet<T>
+where
+    T: QSetElement + ExternType<Kind = cxx::kind::Trivial>,
+{
+    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
+        let mut qset = Self::default();
+        qset.extend(iter);
+        qset
+    }
+}
+
 unsafe impl<T> ExternType for QSet<T>
 where
     T: ExternType + QSetElement,

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

@@ -151,15 +151,22 @@ where
         T::len(self)
     }
 
+    /// Removes the element at index position.
+    pub fn remove(&mut self, pos: isize) {
+        T::remove(self, pos);
+    }
+
     /// Reserve the specified capacity to prevent repeated allocations
     /// when the maximum size is known.
     pub fn reserve(&mut self, size: isize) {
         T::reserve(self, size);
     }
 
-    /// Removes the element at index position.
-    pub fn remove(&mut self, pos: isize) {
-        T::remove(self, pos);
+    /// Helper function for handling Rust values.
+    pub(crate) fn reserve_usize(&mut self, size: usize) {
+        if size != 0 {
+            T::reserve(self, isize::try_from(size).unwrap_or(isize::MAX));
+        }
     }
 }
 
@@ -203,13 +210,60 @@ where
     /// The original slice can still be used after constructing the QVector.
     fn from(vec: S) -> Self {
         let mut qvec = Self::default();
-        qvec.reserve(vec.as_ref().len().try_into().unwrap());
+        qvec.reserve_usize(vec.as_ref().len());
         for element in vec.as_ref() {
             qvec.append_clone(element);
         }
         qvec
     }
 }
+impl<'a, T> Extend<&'a T> for QVector<T>
+where
+    T: QVectorElement,
+{
+    fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I) {
+        let iter = iter.into_iter();
+        self.reserve_usize(iter.size_hint().0);
+        for element in iter {
+            self.append_clone(element);
+        }
+    }
+}
+
+impl<T> Extend<T> for QVector<T>
+where
+    T: QVectorElement + ExternType<Kind = cxx::kind::Trivial>,
+{
+    fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
+        let iter = iter.into_iter();
+        self.reserve_usize(iter.size_hint().0);
+        for element in iter {
+            self.append(element);
+        }
+    }
+}
+
+impl<'a, T> FromIterator<&'a T> for QVector<T>
+where
+    T: QVectorElement,
+{
+    fn from_iter<I: IntoIterator<Item = &'a T>>(iter: I) -> Self {
+        let mut qlist = Self::default();
+        qlist.extend(iter);
+        qlist
+    }
+}
+
+impl<T> FromIterator<T> for QVector<T>
+where
+    T: QVectorElement + ExternType<Kind = cxx::kind::Trivial>,
+{
+    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
+        let mut qlist = Self::default();
+        qlist.extend(iter);
+        qlist
+    }
+}
 
 unsafe impl<T> ExternType for QVector<T>
 where

crates/cxx-qt-lib/src/serde_impl.rs

@@ -8,17 +8,6 @@ use serde::de::{SeqAccess, Visitor};
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use std::fmt::{self, Formatter};
 use std::marker::PhantomData;
-use std::num::NonZeroIsize;
-
-/// Serde deserializers provide an `Option<usize>` size hint, but Qt containers use signed types
-/// for size. This helper function converts between the two.
-/// It also returns `None` if the size hint is 0, because there's no need to reserve capacity of 0.
-const fn get_size_hint(size_hint: Option<usize>) -> Option<NonZeroIsize> {
-    match size_hint {
-        Some(n) if n <= isize::MAX as usize => NonZeroIsize::new(n as isize),
-        _ => None,
-    }
-}
 
 /// Serializes and deserializes a list-like container by iterating over values.
 macro_rules! seq_impl {
@@ -57,8 +46,8 @@ macro_rules! seq_impl {
                         A: SeqAccess<'de>,
                     {
                         let mut values = Self::Value::default();
-                        if let Some(size_hint) = get_size_hint(seq.size_hint()) {
-                            values.reserve(size_hint.get());
+                        if let Some(size_hint) = seq.size_hint() {
+                            values.reserve_usize(size_hint);
                         }
                         while let Some(value) = seq.next_element()? {
                             $insert(&mut values, value);
@@ -107,8 +96,8 @@ macro_rules! deref_impl {
                     {
                         let mut list = Self::Value::default();
                         let values = &mut *list;
-                        if let Some(size_hint) = get_size_hint(seq.size_hint()) {
-                            values.reserve(size_hint.get());
+                        if let Some(size_hint) = seq.size_hint() {
+                            values.reserve_usize(size_hint);
                         }
                         while let Some(value) = seq.next_element()? {
                             values.append(value);