more wip

Author: MatthieuDartiailh

src/types/frozendict.rs

@@ -3,7 +3,7 @@ use crate::ffi::Py_ssize_t;
 use crate::ffi_ptr_ext::FfiPtrExt;
 use crate::instance::Bound;
 use crate::py_result_ext::PyResultExt;
-use crate::types::{PyAny, PyList, PyMapping};
+use crate::types::{PyAny, PyList, PyListMethods, PyMapping};
 use crate::{ffi, Borrowed, BoundObject, IntoPyObject, IntoPyObjectExt, Python};
 #[cfg(RustPython)]
 use crate::{
@@ -222,7 +222,7 @@ impl<'py> PyFrozenDictMethods<'py> for Bound<'py, PyFrozenDict> {
     where
         K: IntoPyObject<'py>,
     {
-        fn inner(
+        fn inner<'py>(
             fd: &Bound<'py, PyFrozenDict>,
             key: Borrowed<'_, '_, PyAny>,
         ) -> PyResult<Option<Bound<'py, PyAny>>> {
@@ -314,13 +314,12 @@ impl<'py> Iterator for BoundFrozenDictIterator<'py> {
 
     fn next(&mut self) -> Option<Self::Item> {
         unsafe {
-            let mut ppos: Py_ssize_t = self.ppos as Py_ssize_t;
+            let mut ppos: *mut ffi::Py_ssize_t = &mut self.ppos;
             let mut key: *mut ffi::PyObject = core::ptr::null_mut();
             let mut value: *mut ffi::PyObject = core::ptr::null_mut();
 
-            if unsafe { ffi::PyDict_Next(dict.as_ptr(), ppos, &mut key, &mut value) != 0 } {
-                *remaining -= 1;
-                let py = dict.py();
+            if unsafe { ffi::PyDict_Next(self.fd.as_ptr(), ppos, &mut key, &mut value) != 0 } {
+                let py = self.py();
                 // Safety:
                 // - PyDict_Next returns borrowed values
                 // - we have already checked that `PyDict_Next` succeeded, so we can assume these to be non-null
@@ -333,6 +332,25 @@ impl<'py> Iterator for BoundFrozenDictIterator<'py> {
             }
         }
     }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let len = ExactSizeIterator::len(self);
+        (len, Some(len))
+    }
+
+    #[inline]
+    fn count(self) -> usize
+    where
+        Self: Sized,
+    {
+        self.fd.len()
+    }
+}
+
+impl ExactSizeIterator for BoundFrozenDictIterator<'_> {
+    fn len(&self) -> usize {
+        self.fd.len()
+    }
 }
 
 #[cfg(Py_3_15)]
@@ -346,22 +364,31 @@ impl<'py> IntoIterator for Bound<'py, PyFrozenDict> {
     }
 }
 
+impl<'py> IntoIterator for &Bound<'py, PyFrozenDict> {
+    type Item = (Bound<'py, PyAny>, Bound<'py, PyAny>);
+    type IntoIter = BoundFrozenDictIterator<'py>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
+
 #[cfg(all(Py_3_15, test))]
 mod tests {
     use super::*;
 
     #[test]
     fn test_frozendict_new() {
         Python::attach(|py| {
-            let fd = PyFrozenDict::new(py, vec![("a", 1), ("b", 2)])?;
+            let fd = PyFrozenDict::new(py, vec![("a", 1), ("b", 2)]).unwrap();
             assert_eq!(fd.len(), 2);
         })
     }
 
     #[test]
     fn test_frozendict_empty() {
         Python::attach(|py| {
-            let fd = PyFrozenDict::empty(py)?;
+            let fd = PyFrozenDict::empty(py).unwrap();
             assert!(fd.is_empty());
             assert_eq!(fd.len(), 0);
         })
@@ -370,7 +397,7 @@ mod tests {
     #[test]
     fn test_frozendict_contains() {
         Python::attach(|py| {
-            let fd = PyFrozenDict::new(py, vec![("a", 1), ("b", 2)])?;
+            let fd = PyFrozenDict::new(py, vec![("a", 1), ("b", 2)]).unwrap();
             assert!(fd.contains("a")?);
             assert!(!fd.contains("c")?);
         })
@@ -379,7 +406,7 @@ mod tests {
     #[test]
     fn test_frozendict_get_item() {
         Python::attach(|py| {
-            let fd = PyFrozenDict::new(py, vec![("a", 1), ("b", 2)])?;
+            let fd = PyFrozenDict::new(py, vec![("a", 1), ("b", 2)]).unwrap();
             let val = fd.get_item("a")?;
             assert!(val.is_some());
         })
@@ -388,7 +415,7 @@ mod tests {
     #[test]
     fn test_frozendict_keys() {
         Python::attach(|py| {
-            let fd = PyFrozenDict::new(py, vec![("a", 1), ("b", 2)])?;
+            let fd = PyFrozenDict::new(py, vec![("a", 1), ("b", 2)]).unwrap();
             let keys = fd.keys();
             assert_eq!(keys.len(), 2);
         })
@@ -397,7 +424,7 @@ mod tests {
     #[test]
     fn test_frozendict_values() {
         Python::attach(|py| {
-            let fd = PyFrozenDict::new(py, vec![("a", 1), ("b", 2)])?;
+            let fd = PyFrozenDict::new(py, vec![("a", 1), ("b", 2)]).unwrap();
             let values = fd.values();
             assert_eq!(values.len(), 2);
         })
@@ -406,7 +433,7 @@ mod tests {
     #[test]
     fn test_frozendict_items() {
         Python::attach(|py| {
-            let fd = PyFrozenDict::new(py, vec![("a", 1), ("b", 2)])?;
+            let fd = PyFrozenDict::new(py, vec![("a", 1), ("b", 2)]).unwrap();
             let items = fd.items();
             assert_eq!(items.len(), 2);
         })
@@ -415,7 +442,7 @@ mod tests {
     #[test]
     fn test_frozendict_iter() {
         Python::attach(|py| {
-            let fd = PyFrozenDict::new(py, vec![("a", 1), ("b", 2)])?;
+            let fd = PyFrozenDict::new(py, vec![("a", 1), ("b", 2)]).unwrap();
             let mut count = 0;
             for (_k, _v) in &fd {
                 count += 1;
@@ -427,15 +454,15 @@ mod tests {
     #[test]
     fn test_frozendict_as_mapping() {
         Python::attach(|py| {
-            let fd = PyFrozenDict::new(py, vec![("a", 1)])?;
+            let fd = PyFrozenDict::new(py, vec![("a", 1)]).unwrap();
             let _mapping = fd.as_mapping();
         })
     }
 
     #[test]
     fn test_frozendict_hash() {
         Python::attach(|py| {
-            let fd = PyFrozenDict::new(py, vec![("a", 1)])?;
+            let fd = PyFrozenDict::new(py, vec![("a", 1)]).unwrap();
             let h = fd.hash()?;
             assert!(h != 0 || fd.is_empty());
         })