Refactoring Iter constructor

EmbarkStudios · Oct 2, 2022 · d54a74a · d54a74a
1 parent 2006ee1
commit d54a74a
Showing 1 changed file with 70 additions and 72 deletions.
diff --git a/src/accessor/util.rs b/src/accessor/util.rs
@@ -287,91 +287,89 @@ impl<'a, 's, T: Item> Iter<'s, T> {
     where
         F: Clone + Fn(buffer::Buffer<'a>) -> Option<&'s [u8]>,
     {
-        let is_sparse = accessor.sparse().is_some();
-        if is_sparse {
-            let sparse = accessor.sparse();
-            let indices = sparse.as_ref().unwrap().indices();
-            let values = sparse.as_ref().unwrap().values();
-            let base_iter = {
+        match accessor.sparse() {
+            Some(sparse) => {
                 // Using `if let` here instead of map to preserve the early return behavior.
-                if let Some(view) = accessor.view() {
+                let base_iter = if let Some(view) = accessor.view() {
                     let stride = view.stride().unwrap_or(mem::size_of::<T>());
+
                     let start = accessor.offset();
                     let end = start + stride * (accessor.count() - 1) + mem::size_of::<T>();
-                    let subslice = if let Some(slice) = buffer_view_slice(view, &get_buffer_data) {
-                        slice.get(start..end)?
-                    } else {
-                        return None;
-                    };
+                    let subslice = buffer_view_slice(view, &get_buffer_data)
+                        .and_then(|slice| slice.get(start..end))?;
+
                     Some(ItemIter::new(subslice, stride))
                 } else {
                     None
-                }
-            };
-            let sparse_count = sparse.as_ref().unwrap().count() as usize;
-            let index_iter = {
-                let view = indices.view();
-                let index_size = indices.index_type().size();
-                let stride = view.stride().unwrap_or(index_size);
-                let subslice = if let Some(slice) = buffer_view_slice(view, &get_buffer_data) {
+                };
+
+                let indices = sparse.indices();
+                let values = sparse.values();
+                let sparse_count = sparse.count() as usize;
+
+                let index_iter = {
+                    let view = indices.view();
+                    let index_size = indices.index_type().size();
+                    let stride = view.stride().unwrap_or(index_size);
+
                     let start = indices.offset() as usize;
                     let end = start + stride * (sparse_count - 1) + index_size;
-                    slice.get(start..end)?
-                } else {
-                    return None;
-                };
-                match indices.index_type() {
-                    accessor::sparse::IndexType::U8 => {
-                        SparseIndicesIter::U8(ItemIter::new(subslice, stride))
-                    }
-                    accessor::sparse::IndexType::U16 => {
-                        SparseIndicesIter::U16(ItemIter::new(subslice, stride))
+                    let subslice = buffer_view_slice(view, &get_buffer_data)
+                        .and_then(|slice| slice.get(start..end))?;
+
+                    match indices.index_type() {
+                        accessor::sparse::IndexType::U8 => {
+                            SparseIndicesIter::U8(ItemIter::new(subslice, stride))
+                        }
+                        accessor::sparse::IndexType::U16 => {
+                            SparseIndicesIter::U16(ItemIter::new(subslice, stride))
+                        }
+                        accessor::sparse::IndexType::U32 => {
+                            SparseIndicesIter::U32(ItemIter::new(subslice, stride))
+                        }
                     }
-                    accessor::sparse::IndexType::U32 => {
-                        SparseIndicesIter::U32(ItemIter::new(subslice, stride))
-                    }
-                }
-            };
-            let value_iter = {
-                let view = values.view();
-                let stride = view.stride().unwrap_or(mem::size_of::<T>());
-                let subslice = if let Some(slice) = buffer_view_slice(view, &get_buffer_data) {
+                };
+
+                let value_iter = {
+                    let view = values.view();
+                    let stride = view.stride().unwrap_or(mem::size_of::<T>());
+
                     let start = values.offset() as usize;
                     let end = start + stride * (sparse_count - 1) + mem::size_of::<T>();
-                    slice.get(start..end)?
-                } else {
-                    return None;
-                };
-                ItemIter::new(subslice, stride)
-            };
-            Some(Iter::Sparse(SparseIter::new(
-                base_iter, index_iter, value_iter,
-            )))
-        } else {
-            debug_assert_eq!(mem::size_of::<T>(), accessor.size());
-            debug_assert!(mem::size_of::<T>() > 0);
-            if let Some(view) = accessor.view() {
-                let stride = view.stride().unwrap_or(mem::size_of::<T>());
-                debug_assert!(
-                    stride >= mem::size_of::<T>(),
-                    "Mismatch in stride, expected at least {} stride but found {}",
-                    mem::size_of::<T>(),
-                    stride
-                );
-                let start = accessor.offset();
-                let end = start + stride * (accessor.count() - 1) + mem::size_of::<T>();
-                let subslice = if let Some(slice) = buffer_view_slice(view, &get_buffer_data) {
-                    slice.get(start..end)?
-                } else {
-                    return None;
+                    let subslice = buffer_view_slice(view, &get_buffer_data)
+                        .and_then(|slice| slice.get(start..end))?;
+
+                    ItemIter::new(subslice, stride)
                 };
-                Some(Iter::Standard(ItemIter {
-                    stride,
-                    data: subslice,
-                    _phantom: PhantomData,
-                }))
-            } else {
-                None
+
+                Some(Iter::Sparse(SparseIter::new(
+                    base_iter, index_iter, value_iter,
+                )))
+            }
+            None => {
+                debug_assert_eq!(mem::size_of::<T>(), accessor.size());
+                debug_assert!(mem::size_of::<T>() > 0);
+
+                accessor.view().and_then(|view| {
+                    let stride = view.stride().unwrap_or(mem::size_of::<T>());
+                    debug_assert!(
+                        stride >= mem::size_of::<T>(),
+                        "Mismatch in stride, expected at least {} stride but found {}",
+                        mem::size_of::<T>(),
+                        stride
+                    );
+
+                    let start = accessor.offset();
+                    let end = start + stride * (accessor.count() - 1) + mem::size_of::<T>();
+                    let subslice = buffer_view_slice(view, &get_buffer_data)
+                        .and_then(|slice| slice.get(start..end))?;
+
+                    Some(Iter::Standard(ItemIter {
+                        stride,
+                        data: subslice,
+                        _phantom: PhantomData,
+                    }))
+                })
             }
         }
     }