Refactor

danog · danog · commit 91dcc38e5089 · 2023-11-24T16:50:58.000+01:00
diff --git a/src/types/array.rs b/src/types/array.rs
@@ -576,13 +576,13 @@ pub struct Iter<'a> {
 }
 
 #[derive(Debug, PartialEq)]
-pub enum ArrayKey<'a> {
+pub enum ArrayKey {
     Long(i64),
-    String(&'a str),
+    String(String),
 }
 
 /// Represent the key of a PHP array, which can be either a long or a string.
-impl<'a> ArrayKey<'a> {
+impl ArrayKey {
     /// Check if the key is an integer.
     ///
     /// # Returns
@@ -596,7 +596,7 @@ impl<'a> ArrayKey<'a> {
     }
 }
 
-impl<'a> Display for ArrayKey<'a> {
+impl Display for ArrayKey {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             ArrayKey::Long(key) => write!(f, "{}", key),
@@ -605,17 +605,17 @@ impl<'a> Display for ArrayKey<'a> {
     }
 }
 
-impl<'a> FromZval<'_> for ArrayKey<'a> {
+impl<'a> FromZval<'a> for ArrayKey {
     const TYPE: DataType = DataType::String;
 
-    fn from_zval(zval: &Zval) -> Option<Self> {
+    fn from_zval(zval: &'a Zval) -> Option<Self> {
         if let Some(key) = zval.long() {
             return Some(ArrayKey::Long(key));
         }
-        if let Some(key) = zval.str() {
+        if let Some(key) = zval.string() {
             return Some(ArrayKey::String(key));
         }
-        return None;
+        None
     }
 }
 
@@ -635,7 +635,7 @@ impl<'a> Iter<'a> {
 }
 
 impl<'a> IntoIterator for &'a ZendHashTable {
-    type Item = (ArrayKey<'a>, &'a Zval);
+    type Item = (ArrayKey, &'a Zval);
     type IntoIter = Iter<'a>;
 
     /// Returns an iterator over the key(s) and value contained inside the
@@ -662,9 +662,28 @@ impl<'a> IntoIterator for &'a ZendHashTable {
 }
 
 impl<'a> Iterator for Iter<'a> {
-    type Item = (ArrayKey<'a>, &'a Zval);
+    type Item = (ArrayKey, &'a Zval);
 
     fn next(&mut self) -> Option<Self::Item> {
+        self.next_zval().map(|(k, v)| (ArrayKey::from_zval(&k).expect("Invalid array key!"), v))
+    }
+
+    fn count(self) -> usize
+    where
+        Self: Sized,
+    {
+        self.ht.len()
+    }
+}
+
+impl<'a> ExactSizeIterator for Iter<'a> {
+    fn len(&self) -> usize {
+        self.ht.len()
+    }
+}
+
+impl<'a> DoubleEndedIterator for Iter<'a> {
+    fn next_back(&mut self) -> Option<Self::Item> {
         let key_type = unsafe {
             zend_hash_get_current_key_type_ex(
                 self.ht as *const ZendHashTable as *mut ZendHashTable,
@@ -677,6 +696,7 @@ impl<'a> Iterator for Iter<'a> {
         }
 
         let key = Zval::new();
+
         unsafe {
             zend_hash_get_current_key_zval_ex(
                 self.ht as *const ZendHashTable as *mut ZendHashTable,
@@ -697,32 +717,19 @@ impl<'a> Iterator for Iter<'a> {
         };
 
         unsafe {
-            zend_hash_move_forward_ex(
+            zend_hash_move_backwards_ex(
                 self.ht as *const ZendHashTable as *mut ZendHashTable,
                 &mut self.pos as *mut HashPosition,
             )
         };
-        self.current_num += 1;
+        self.current_num -= 1;
 
         Some((key, value))
     }
-
-    fn count(self) -> usize
-    where
-        Self: Sized,
-    {
-        self.ht.len()
-    }
-}
-
-impl<'a> ExactSizeIterator for Iter<'a> {
-    fn len(&self) -> usize {
-        self.ht.len()
-    }
 }
 
-impl<'a> DoubleEndedIterator for Iter<'a> {
-    fn next_back(&mut self) -> Option<Self::Item> {
+impl<'a, 'b> Iter<'a> {
+    pub fn next_zval(&'b mut self) -> Option<(Zval, &'a Zval)> {
         let key_type = unsafe {
             zend_hash_get_current_key_type_ex(
                 self.ht as *const ZendHashTable as *mut ZendHashTable,
@@ -734,7 +741,8 @@ impl<'a> DoubleEndedIterator for Iter<'a> {
             return None;
         }
 
-        let key = Zval::new();
+        let mut key = Zval::new();
+
         unsafe {
             zend_hash_get_current_key_zval_ex(
                 self.ht as *const ZendHashTable as *mut ZendHashTable,
@@ -749,20 +757,19 @@ impl<'a> DoubleEndedIterator for Iter<'a> {
             )
         };
 
-        let r = match ArrayKey::from_zval(&key) {
-            Some(key) => (key, value),
-            None => (ArrayKey::Long(self.current_num), value),
-        };
+        if !key.is_long() && !key.is_string() {
+            key.set_long(self.current_num)
+        }
 
         unsafe {
-            zend_hash_move_backwards_ex(
+            zend_hash_move_forward_ex(
                 self.ht as *const ZendHashTable as *mut ZendHashTable,
                 &mut self.pos as *mut HashPosition,
             )
         };
-        self.current_num -= 1;
+        self.current_num += 1;
 
-        Some(r)
+        Some((key, value))
     }
 }
 
diff --git a/src/types/iterable.rs b/src/types/iterable.rs
@@ -1,4 +1,4 @@
-use super::array::{ArrayKey, Iter as ZendHashTableIter};
+use super::array::Iter as ZendHashTableIter;
 use super::iterator::Iter as ZendIteratorIter;
 use crate::convert::FromZval;
 use crate::flags::DataType;
@@ -24,7 +24,7 @@ impl<'a> Iterable<'a> {
 }
 
 impl<'a> IntoIterator for &'a mut Iterable<'a> {
-    type Item = (&'a Zval, &'a Zval);
+    type Item = (Zval, &'a Zval);
     type IntoIter = Iter<'a>;
 
     fn into_iter(self) -> Self::IntoIter {
@@ -55,15 +55,11 @@ pub enum Iter<'a> {
 }
 
 impl<'a> Iterator for Iter<'a> {
-    type Item = (&'a Zval, &'a Zval);
+    type Item = (Zval, &'a Zval);
 
     fn next(&mut self) -> Option<Self::Item> {
         match self {
-            Iter::Array(array) => match array.next() {
-                Some((ArrayKey::Long(k), v)) => Zval::new().set_long(v),
-                Some((ArrayKey::String(k), v)) => Zval::new().set_string(v),
-                None => None,
-            },
+            Iter::Array(array) => array.next_zval(),
             Iter::Traversable(traversable) => traversable.next(),
         }
     }
diff --git a/src/types/iterator.rs b/src/types/iterator.rs
@@ -1,9 +1,9 @@
-use crate::convert::{FromZval, FromZvalMut};
+use crate::convert::FromZvalMut;
 use crate::ffi::{zend_object_iterator, ZEND_RESULT_CODE_SUCCESS};
 use crate::flags::DataType;
 use crate::types::Zval;
 use crate::zend::ExecutorGlobals;
-use std::fmt::{Debug, Display, Formatter};
+use std::fmt::{Debug, Formatter};
 
 /// A PHP Iterator.
 ///
@@ -124,7 +124,7 @@ impl ZendIterator {
 }
 
 impl<'a> IntoIterator for &'a mut ZendIterator {
-    type Item = (&'a Zval, &'a Zval);
+    type Item = (Zval, &'a Zval);
     type IntoIter = Iter<'a>;
 
     fn into_iter(self) -> Self::IntoIter {
@@ -144,7 +144,7 @@ pub struct Iter<'a> {
 }
 
 impl<'a> Iterator for Iter<'a> {
-    type Item = (&'a Zval, &'a Zval);
+    type Item = (Zval, &'a Zval);
 
     fn next(&mut self) -> Option<Self::Item> {
         // Call next when index > 0, so next is really called at the start of each
@@ -162,11 +162,12 @@ impl<'a> Iterator for Iter<'a> {
         let real_index = self.zi.index - 1;
 
         let key = match self.zi.get_current_key() {
-            None => IterKey::Long(real_index),
-            Some(key) => match IterKey::from_zval(&key) {
-                Some(key) => key,
-                None => IterKey::Long(real_index),
-            },
+            None => {
+                let mut z = Zval::new();
+                z.set_long(real_index as i64);
+                z
+            }
+            Some(key) => key,
         };
 
         self.zi.get_current_data().map(|value| (key, value))
