Move utility functions only used by io module

Author: w1th0utnam3

splashsurf_lib/src/io.rs

@@ -6,6 +6,7 @@ use nalgebra::Vector3;
 use std::path::Path;
 
 pub mod bgeo_format;
+mod io_utils;
 pub mod json_format;
 pub mod obj_format;
 pub mod ply_format;

splashsurf_lib/src/io/bgeo_format.rs

@@ -1,8 +1,8 @@
 //! Helper functions for the BGEO file format
 
+use crate::io::io_utils::IteratorExt;
 use crate::mesh::{AttributeData, MeshAttribute};
-use crate::utils::IteratorExt;
-use crate::{Real, utils};
+use crate::{Real, io::io_utils};
 use anyhow::{Context, anyhow};
 use flate2::Compression;
 use flate2::read::GzDecoder;
@@ -340,15 +340,15 @@ impl AttributeStorage {
     /// Tries to convert this BGEO attribute storage into a mesh [`AttributeData`] storage
     fn try_into_attribute_data<R: Real>(&self) -> Result<AttributeData<R>, anyhow::Error> {
         match self {
-            AttributeStorage::Int(data) => utils::try_convert_scalar_slice(data, u64::from_i32)
+            AttributeStorage::Int(data) => io_utils::try_convert_scalar_slice(data, u64::from_i32)
                 .map(|v| AttributeData::ScalarU64(v))
                 .context(anyhow!("failed to convert integer attribute")),
-            AttributeStorage::Float(data) => utils::try_convert_scalar_slice(data, R::from_f32)
+            AttributeStorage::Float(data) => io_utils::try_convert_scalar_slice(data, R::from_f32)
                 .map(|v| AttributeData::ScalarReal(v))
                 .context(anyhow!("failed to convert float attribute")),
             AttributeStorage::Vector(n, data) => {
                 if *n == 3 {
-                    utils::try_convert_scalar_slice_to_vectors(data, R::from_f32)
+                    io_utils::try_convert_scalar_slice_to_vectors(data, R::from_f32)
                         .map(|v| AttributeData::Vector3Real(v))
                         .context(anyhow!("failed to convert vector attribute"))
                 } else {

splashsurf_lib/src/io/io_utils.rs

@@ -0,0 +1,114 @@
+use anyhow::{Context, anyhow};
+use nalgebra::{SVector, Scalar};
+use num_traits::Zero;
+use std::fmt::Debug;
+
+/// Converts a slice of scalar values to a vector of the same length, returns an error if conversion fails
+pub fn try_convert_scalar_slice<
+    ScalarFrom: Copy + Debug,
+    ScalarTo,
+    F: Fn(ScalarFrom) -> Option<ScalarTo>,
+>(
+    values: &[ScalarFrom],
+    f: F,
+) -> Result<Vec<ScalarTo>, anyhow::Error> {
+    values
+        .iter()
+        .copied()
+        .map(|v| {
+            f(v).ok_or_else(|| {
+                anyhow!(
+                    "failed to convert value {:?} from type {} to {}",
+                    v,
+                    std::any::type_name::<ScalarFrom>(),
+                    std::any::type_name::<ScalarTo>()
+                )
+            })
+        })
+        .try_collect_with_capacity(values.len())
+}
+
+/// Converts a slice of scalar values to a vector of [`nalgebra::SVector`], returns an error if conversion fails or the input slice's length is not a multiple of the vector length.
+pub fn try_convert_scalar_slice_to_vectors<
+    const N: usize,
+    ScalarFrom: Copy + Debug,
+    ScalarTo: Scalar + Zero,
+    F: Fn(ScalarFrom) -> Option<ScalarTo>,
+>(
+    values: &[ScalarFrom],
+    f: F,
+) -> Result<Vec<SVector<ScalarTo, N>>, anyhow::Error> {
+    {
+        if values.len() % N != 0 {
+            Err(anyhow!("input slice length is not a multiple of {}", N))
+        } else {
+            values
+                .chunks_exact(N)
+                .map(|v| {
+                    let mut v_out = SVector::zeros();
+                    for i in 0..N {
+                        v_out[i] = f(v[i]).ok_or_else(|| {
+                            anyhow!(
+                                "failed to convert value {:?} from type {} to {}",
+                                v,
+                                std::any::type_name::<ScalarFrom>(),
+                                std::any::type_name::<ScalarTo>()
+                            )
+                        })?;
+                    }
+                    Ok(v_out)
+                })
+                .try_collect_with_capacity(values.len() / N)
+        }
+    }
+    .context(anyhow!(
+        "failed to convert scalar slice to vectors of length {}",
+        N
+    ))
+}
+
+#[cfg(test)]
+mod tests {
+    use num_traits::FromPrimitive;
+    #[test]
+    fn test_try_convert_scalar_slice() {
+        let values = vec![1, -1];
+        assert!(super::try_convert_scalar_slice(&values, u64::from_i32).is_err());
+        let values = vec![1, -1];
+        assert_eq!(
+            super::try_convert_scalar_slice(&values, f32::from_i64).unwrap(),
+            vec![1.0, -1.0]
+        );
+    }
+}
+
+/// "Convert" an empty vector to preserve allocated memory if size and alignment matches
+/// See https://users.rust-lang.org/t/pattern-how-to-reuse-a-vec-str-across-loop-iterations/61657/5
+/// See https://github.com/rust-lang/rfcs/pull/2802
+#[allow(unused)]
+pub(crate) fn recycle<A, B>(mut v: Vec<A>) -> Vec<B> {
+    v.clear();
+    v.into_iter().map(|_| unreachable!()).collect()
+}
+
+/// Useful extension methods for iterators
+pub(crate) trait IteratorExt {
+    /// Tries to collect the items of the iterator into a `Vec` that reserves the given capacity and stops as soon as an error is encountered
+    ///
+    /// Motivation: <https://github.com/rust-lang/rust/issues/48994>
+    fn try_collect_with_capacity<T, E>(self, capacity: usize) -> Result<Vec<T>, E>
+    where
+        Self: Sized + Iterator<Item = Result<T, E>>;
+}
+
+impl<Iter: Iterator> IteratorExt for Iter {
+    fn try_collect_with_capacity<T, E>(mut self, capacity: usize) -> Result<Vec<T>, E>
+    where
+        Self: Sized + Iterator<Item = Result<T, E>>,
+    {
+        self.try_fold(Vec::with_capacity(capacity), |mut vec, item| {
+            vec.push(item?);
+            Ok(vec)
+        })
+    }
+}

splashsurf_lib/src/io/json_format.rs

@@ -1,6 +1,6 @@
 //! Helper functions for the JSON file format
 
-use crate::utils::IteratorExt;
+use crate::io::io_utils::IteratorExt;
 use crate::{Real, RealConvert};
 use anyhow::{Context, anyhow};
 use nalgebra::Vector3;

splashsurf_lib/src/io/obj_format.rs

@@ -3,7 +3,7 @@
 use crate::mesh::{
     AttributeData, CellConnectivity, Mesh3d, MeshAttribute, MeshWithData, TriMesh3d,
 };
-use crate::{Real, profile, utils};
+use crate::{Real, io::io_utils, profile};
 use anyhow::Context;
 use nalgebra::Vector3;
 use std::fs;
@@ -92,7 +92,7 @@ pub fn surface_mesh_from_obj<R: Real, P: AsRef<Path>>(
     let mut buffer_string = String::new();
 
     loop {
-        let mut buffer = utils::recycle(outer_buffer);
+        let mut buffer = io_utils::recycle(outer_buffer);
 
         let read = reader.read_line(&mut buffer_string)?;
         if read == 0 {
@@ -134,7 +134,7 @@ pub fn surface_mesh_from_obj<R: Real, P: AsRef<Path>>(
             normals.push(buffer_to_vec3(&buffer)?);
         }
 
-        outer_buffer = utils::recycle(buffer);
+        outer_buffer = io_utils::recycle(buffer);
         buffer_string.clear();
     }
 

splashsurf_lib/src/io/ply_format.rs

@@ -1,9 +1,9 @@
 //! Helper functions for the PLY file format
 
+use crate::io::io_utils::IteratorExt;
 use crate::mesh::{
     AttributeData, CellConnectivity, Mesh3d, MeshAttribute, MeshWithData, TriMesh3d,
 };
-use crate::utils::IteratorExt;
 use crate::{Real, profile};
 use anyhow::{Context, anyhow};
 use nalgebra::Vector3;

splashsurf_lib/src/io/vtk_format.rs

@@ -1,8 +1,8 @@
 //! Helper functions for the VTK file format
 
+use crate::io::io_utils::IteratorExt;
 use crate::mesh::{AttributeData, IntoVtkDataSet, MeshAttribute, MeshWithData, TriMesh3d};
-use crate::utils::IteratorExt;
-use crate::{Real, RealConvert, profile, utils};
+use crate::{Real, RealConvert, io::io_utils, profile};
 use anyhow::{Context, anyhow};
 use nalgebra::Vector3;
 use std::borrow::Cow;
@@ -318,11 +318,11 @@ fn try_convert_io_buffer_to_attribute<R: Real>(
 ) -> Result<AttributeData<R>, anyhow::Error> {
     match num_comp {
         1 => match &io_buffer {
-            IOBuffer::U32(vec) => utils::try_convert_scalar_slice(vec, R::from_u32)
+            IOBuffer::U32(vec) => io_utils::try_convert_scalar_slice(vec, R::from_u32)
                 .map(|v| AttributeData::ScalarReal(v)),
-            IOBuffer::F32(vec) => utils::try_convert_scalar_slice(vec, R::from_f32)
+            IOBuffer::F32(vec) => io_utils::try_convert_scalar_slice(vec, R::from_f32)
                 .map(|v| AttributeData::ScalarReal(v)),
-            IOBuffer::F64(vec) => utils::try_convert_scalar_slice(vec, R::from_f64)
+            IOBuffer::F64(vec) => io_utils::try_convert_scalar_slice(vec, R::from_f64)
                 .map(|v| AttributeData::ScalarReal(v)),
             _ => Err(anyhow!("Unsupported IOBuffer scalar data type")),
         },
@@ -346,7 +346,7 @@ fn try_convert_io_buffer_to_attribute<R: Real>(
 fn particles_from_coords<RealOut: Real, RealIn: Real>(
     coords: &[RealIn],
 ) -> Result<Vec<Vector3<RealOut>>, anyhow::Error> {
-    utils::try_convert_scalar_slice_to_vectors(coords, |v| v.try_convert())
+    io_utils::try_convert_scalar_slice_to_vectors(coords, |v| v.try_convert())
         .context(anyhow!("failed to convert particle coordinates"))
 }
 

splashsurf_lib/src/utils.rs

@@ -1,100 +1,8 @@
 //! Internal helper functions and types
 
-use anyhow::{Context, anyhow};
 use log::info;
-use nalgebra::{SVector, Scalar};
-use num_traits::Zero;
 use rayon::prelude::*;
 use std::cell::UnsafeCell;
-use std::fmt::Debug;
-
-/// Converts a slice of scalar values to a vector of the same length, returns an error if conversion fails
-pub fn try_convert_scalar_slice<
-    ScalarFrom: Copy + Debug,
-    ScalarTo,
-    F: Fn(ScalarFrom) -> Option<ScalarTo>,
->(
-    values: &[ScalarFrom],
-    f: F,
-) -> Result<Vec<ScalarTo>, anyhow::Error> {
-    values
-        .iter()
-        .copied()
-        .map(|v| {
-            f(v).ok_or_else(|| {
-                anyhow!(
-                    "failed to convert value {:?} from type {} to {}",
-                    v,
-                    std::any::type_name::<ScalarFrom>(),
-                    std::any::type_name::<ScalarTo>()
-                )
-            })
-        })
-        .try_collect_with_capacity(values.len())
-}
-
-/// Converts a slice of scalar values to a vector of [`nalgebra::SVector`], returns an error if conversion fails or the input slice's length is not a multiple of the vector length.
-pub fn try_convert_scalar_slice_to_vectors<
-    const N: usize,
-    ScalarFrom: Copy + Debug,
-    ScalarTo: Scalar + Zero,
-    F: Fn(ScalarFrom) -> Option<ScalarTo>,
->(
-    values: &[ScalarFrom],
-    f: F,
-) -> Result<Vec<SVector<ScalarTo, N>>, anyhow::Error> {
-    {
-        if values.len() % N != 0 {
-            Err(anyhow!("input slice length is not a multiple of {}", N))
-        } else {
-            values
-                .chunks_exact(N)
-                .map(|v| {
-                    let mut v_out = SVector::zeros();
-                    for i in 0..N {
-                        v_out[i] = f(v[i]).ok_or_else(|| {
-                            anyhow!(
-                                "failed to convert value {:?} from type {} to {}",
-                                v,
-                                std::any::type_name::<ScalarFrom>(),
-                                std::any::type_name::<ScalarTo>()
-                            )
-                        })?;
-                    }
-                    Ok(v_out)
-                })
-                .try_collect_with_capacity(values.len() / N)
-        }
-    }
-    .context(anyhow!(
-        "failed to convert scalar slice to vectors of length {}",
-        N
-    ))
-}
-
-#[cfg(test)]
-mod tests {
-    use num_traits::FromPrimitive;
-    #[test]
-    fn test_try_convert_scalar_slice() {
-        let values = vec![1, -1];
-        assert!(super::try_convert_scalar_slice(&values, u64::from_i32).is_err());
-        let values = vec![1, -1];
-        assert_eq!(
-            super::try_convert_scalar_slice(&values, f32::from_i64).unwrap(),
-            vec![1.0, -1.0]
-        );
-    }
-}
-
-/// "Convert" an empty vector to preserve allocated memory if size and alignment matches
-/// See https://users.rust-lang.org/t/pattern-how-to-reuse-a-vec-str-across-loop-iterations/61657/5
-/// See https://github.com/rust-lang/rfcs/pull/2802
-#[allow(unused)]
-pub(crate) fn recycle<A, B>(mut v: Vec<A>) -> Vec<B> {
-    v.clear();
-    v.into_iter().map(|_| unreachable!()).collect()
-}
 
 /// Macro version of Option::map that allows using e.g. using the ?-operator in the map expression
 ///
@@ -111,28 +19,6 @@ macro_rules! map_option {
     };
 }
 
-/// Useful extension methods for iterators
-pub(crate) trait IteratorExt {
-    /// Tries to collect the items of the iterator into a `Vec` that reserves the given capacity and stops as soon as an error is encountered
-    ///
-    /// Motivation: <https://github.com/rust-lang/rust/issues/48994>
-    fn try_collect_with_capacity<T, E>(self, capacity: usize) -> Result<Vec<T>, E>
-    where
-        Self: Sized + Iterator<Item = Result<T, E>>;
-}
-
-impl<Iter: Iterator> IteratorExt for Iter {
-    fn try_collect_with_capacity<T, E>(mut self, capacity: usize) -> Result<Vec<T>, E>
-    where
-        Self: Sized + Iterator<Item = Result<T, E>>,
-    {
-        self.try_fold(Vec::with_capacity(capacity), |mut vec, item| {
-            vec.push(item?);
-            Ok(vec)
-        })
-    }
-}
-
 /// Wrapper for unsafe shared mutable access to a slice, disjoint access has to be ensured separately
 /// Implementation based on: <https://stackoverflow.com/a/65182786/929037>
 #[derive(Copy, Clone)]