Add iterators for streams, provide .iter on device list

This slightly reworks the DeviceList iterator, but not much.

Topic: stream-iterators

Author: wolfd

src/device.rs

@@ -289,6 +289,11 @@ impl<'a> DeviceList<'a> {
 
         device.map(Device::new).map_err(OrbbecError::from)
     }
+
+    /// Get an iterator over the devices in the list.
+    pub fn iter(&self) -> DeviceListIterator<'a, '_> {
+        DeviceListIterator::new(self)
+    }
 }
 
 /// An iterator over the devices in a device list
@@ -299,12 +304,12 @@ pub struct DeviceListIterator<'a, 'b> {
 }
 
 impl<'a, 'b> DeviceListIterator<'a, 'b> {
-    fn new(device_list: &'a DeviceList<'b>) -> Result<Self, OrbbecError> {
-        Ok(DeviceListIterator {
+    fn new(device_list: &'b DeviceList<'a>) -> Self {
+        DeviceListIterator {
             device_list,
             index: 0,
             count: device_list.len(),
-        })
+        }
     }
 }
 
@@ -313,12 +318,12 @@ impl<'a, 'b> Iterator for DeviceListIterator<'a, 'b> {
 
     fn next(&mut self) -> Option<Self::Item> {
         if self.index >= self.count {
-            None
-        } else {
-            let device = self.device_list.get(self.index);
-            self.index += 1;
-            Some(device)
+            return None;
         }
+
+        let device = self.device_list.get(self.index);
+        self.index += 1;
+        Some(device)
     }
 }
 
@@ -330,6 +335,6 @@ where
     type IntoIter = DeviceListIterator<'a, 'b>;
 
     fn into_iter(self) -> Self::IntoIter {
-        DeviceListIterator::<'a, 'b>::new(self).unwrap()
+        self.iter()
     }
 }

src/stream.rs

@@ -96,4 +96,70 @@ impl StreamProfileList {
             .map(VideoStreamProfile::new)
             .map_err(OrbbecError::from)
     }
+
+    /// Get the number of stream profiles in this list
+    pub fn len(&self) -> Result<usize, OrbbecError> {
+        self.inner
+            .get_count()
+            .map(|count| count as usize)
+            .map_err(OrbbecError::from)
+    }
+
+    /// Return whether this list has no profiles
+    pub fn is_empty(&self) -> Result<bool, OrbbecError> {
+        Ok(self.len()? == 0)
+    }
+
+    /// Get the video stream profile at `index`
+    pub fn get(&self, index: usize) -> Result<VideoStreamProfile, OrbbecError> {
+        self.inner
+            .get_stream_profile(index as u32)
+            .map(VideoStreamProfile::new)
+            .map_err(OrbbecError::from)
+    }
+
+    /// Get an iterator over the stream profiles in the list.
+    pub fn iter(&self) -> StreamProfileListIterator<'_> {
+        StreamProfileListIterator::new(self)
+    }
+}
+
+/// An iterator over video stream profiles in a stream profile list
+pub struct StreamProfileListIterator<'a> {
+    profile_list: &'a StreamProfileList,
+    index: usize,
+    count: usize,
+}
+
+impl<'a> StreamProfileListIterator<'a> {
+    fn new(profile_list: &'a StreamProfileList) -> Self {
+        StreamProfileListIterator {
+            profile_list,
+            index: 0,
+            count: profile_list.len().unwrap(),
+        }
+    }
+}
+
+impl<'a> Iterator for StreamProfileListIterator<'a> {
+    type Item = Result<VideoStreamProfile, OrbbecError>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.index >= self.count {
+            None
+        } else {
+            let profile = self.profile_list.get(self.index);
+            self.index += 1;
+            Some(profile)
+        }
+    }
+}
+
+impl<'a> IntoIterator for &'a StreamProfileList {
+    type Item = Result<VideoStreamProfile, OrbbecError>;
+    type IntoIter = StreamProfileListIterator<'a>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
 }

src/sys/stream.rs

@@ -86,27 +86,27 @@ impl OBStreamProfileList {
         OBStreamProfileList { inner }
     }
 
-    // /// Get the number of stream profiles in the list
-    // pub fn get_count(&self) -> Result<u32, OBError> {
-    //     let mut err_ptr = std::ptr::null_mut();
+    /// Get the number of stream profiles in the list
+    pub fn get_count(&self) -> Result<u32, OBError> {
+        let mut err_ptr = std::ptr::null_mut();
 
-    //     let count = unsafe { orb::ob_stream_profile_list_get_count(self.inner, &mut err_ptr) };
-    //     OBError::consume(err_ptr)?;
+        let count = unsafe { orb::ob_stream_profile_list_get_count(self.inner, &mut err_ptr) };
+        OBError::consume(err_ptr)?;
 
-    //     Ok(count)
-    // }
+        Ok(count)
+    }
 
-    // /// Get the stream profile at the specified index
-    // pub fn get_stream_profile(&self, index: i32) -> Result<OBStreamProfile, OBError> {
-    //     let mut err_ptr = std::ptr::null_mut();
+    /// Get the stream profile at the specified index
+    pub fn get_stream_profile(&self, index: u32) -> Result<OBStreamProfile, OBError> {
+        let mut err_ptr = std::ptr::null_mut();
 
-    //     let profile = unsafe {
-    //         orb::ob_stream_profile_list_get_profile(self.inner, index as c_int, &mut err_ptr)
-    //     };
-    //     OBError::consume(err_ptr)?;
+        let profile = unsafe {
+            orb::ob_stream_profile_list_get_profile(self.inner, index as i32, &mut err_ptr)
+        };
+        OBError::consume(err_ptr)?;
 
-    //     Ok(OBStreamProfile::new(profile))
-    // }
+        Ok(OBStreamProfile::new(profile))
+    }
 
     /// Match the corresponding ob_stream_profile through the passed parameters. If there are multiple matches, the first one in the list will be returned by default.
     pub fn get_video_stream_profile(