From c104a2240731c7ef8266832c0a480d11a23594d6 Mon Sep 17 00:00:00 2001 From: Lionel Sambuc Date: Fri, 9 Aug 2024 18:44:29 +0200 Subject: [PATCH] Updated dependencies and fixed linter warnings --- Cargo.toml | 8 ++++---- src/database/db_core.rs | 10 +++------- src/database/mod.rs | 2 +- src/database/space/coordinate.rs | 8 ++++---- src/database/space/coordinate_system.rs | 4 ++-- src/database/space/position.rs | 26 +++++++++++++++---------- src/database/space/shape.rs | 2 +- src/database/space_db.rs | 3 ++- src/database/space_index.rs | 2 +- src/storage/model.rs | 23 ++++++++++------------ src/storage/xyz.rs | 4 +++- 11 files changed, 47 insertions(+), 45 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index e0d028c..c3cab6b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -39,17 +39,17 @@ ironsea_index_sfc_dbc = "0.1" ironsea_index_hashmap = "0.1" arrayref = "0.3" # For Positions Objects -lazy_static = "1.4" +lazy_static = "1.5" memmap = "0.7" serde = { version = "1.0", features = ["derive"] } serde_json = "1.0" -bincode = "1.3.0" +bincode = "1.3" # Logging macros API #log = { version = "0.4", features = ["max_level_trace", "release_max_level_info"] } log = { version = "0.4", features = ["max_level_trace", "release_max_level_trace"] } # Used for main.rs as integration test -pretty_env_logger = { version = "0.3", optional = true } # Logger implementation -measure_time = { version = "0.6", optional = true } # To mesure parsing time, only required by binary +pretty_env_logger = { version = "0.5", optional = true } # Logger implementation +measure_time = { version = "0.8", optional = true } # To mesure parsing time, only required by binary diff --git a/src/database/db_core.rs b/src/database/db_core.rs index e1b3b56..868a199 100644 --- a/src/database/db_core.rs +++ b/src/database/db_core.rs @@ -176,11 +176,7 @@ impl Core { // We cannot return less that the total number of individual Ids stored // in the index for a full-volume query. - let max_elements = if let Some(elem) = max_elements { - Some(elem.max(properties.len())) - } else { - None - }; + let max_elements = max_elements.map(|elem| elem.max(properties.len())); for space in spaces { // Filter the points of this space, and encode them before creating the index. @@ -196,7 +192,7 @@ impl Core { object.set_position(space.encode(&position)?); } - space_dbs.push(SpaceDB::new(&space, filtered, scales.clone(), max_elements)) + space_dbs.push(SpaceDB::new(space, filtered, scales.clone(), max_elements)) } Ok(Core { @@ -504,7 +500,7 @@ impl Core { }, } }) - .flat_map(|v| v); + .flatten(); // Select based on the volume, and filter out the label position themselves. for s in &self.space_db { diff --git a/src/database/mod.rs b/src/database/mod.rs index 7b15eac..8b0aca4 100644 --- a/src/database/mod.rs +++ b/src/database/mod.rs @@ -116,7 +116,7 @@ impl DataBase { list.len() )) } else { - Ok(&list[0]) + Ok(list[0]) } } diff --git a/src/database/space/coordinate.rs b/src/database/space/coordinate.rs index 2ae4bc2..7d7bd3b 100644 --- a/src/database/space/coordinate.rs +++ b/src/database/space/coordinate.rs @@ -206,10 +206,10 @@ impl From for Coordinate { // Slight syntax hack, as exclusive ranges are not yet available. // cf: https://github.com/rust-lang/rust/issues/37854 match v { - _ if v <= u64::from(std::u8::MAX) => Coordinate::CoordinateU8(v as u8), - _ if v <= u64::from(std::u16::MAX) => Coordinate::CoordinateU16(v as u16), - _ if v <= u64::from(std::u32::MAX) => Coordinate::CoordinateU32(v as u32), - _ => Coordinate::CoordinateU64(v as u64), + _ if v <= u64::from(u8::MAX) => Coordinate::CoordinateU8(v as u8), + _ if v <= u64::from(u16::MAX) => Coordinate::CoordinateU16(v as u16), + _ if v <= u64::from(u32::MAX) => Coordinate::CoordinateU32(v as u32), + _ => Coordinate::CoordinateU64(v), /*_ => { panic!("Out of range {} > {}", v, std::u64::MAX); } */ diff --git a/src/database/space/coordinate_system.rs b/src/database/space/coordinate_system.rs index 3877703..77c20fd 100644 --- a/src/database/space/coordinate_system.rs +++ b/src/database/space/coordinate_system.rs @@ -84,8 +84,8 @@ impl CoordinateSystem { match self { CoordinateSystem::Universe { .. } => { for _ in 0..self.dimensions() { - low.push(std::f64::MIN); - high.push(std::f64::MAX); + low.push(f64::MIN); + high.push(f64::MAX); } } CoordinateSystem::AffineSystem { axes, .. } => { diff --git a/src/database/space/position.rs b/src/database/space/position.rs index 0e82c8d..0ec5b93 100644 --- a/src/database/space/position.rs +++ b/src/database/space/position.rs @@ -19,7 +19,7 @@ use serde::Serialize; use super::coordinate::Coordinate; /// Store a position as efficiently as possible in terms of space. -#[derive(Clone, Debug, Deserialize, Eq, Hash, Ord, PartialEq, Serialize)] +#[derive(Clone, Debug, Deserialize, Eq, Hash, PartialEq, Serialize)] pub enum Position { /// 1 dimension positions. Position1(Coordinate), @@ -128,6 +128,12 @@ impl Display for Position { } } +impl Ord for Position { + fn cmp(&self, other: &Self) -> Ordering { + self.partial_cmp(other).unwrap() + } +} + impl PartialOrd for Position { fn partial_cmp(&self, other: &Self) -> Option { // Let's restrict for now to same-length vectors. @@ -144,7 +150,7 @@ impl PartialOrd for Position { return None; } - let ordering = ordering.drain().filter_map(|v| v).collect::>(); + let ordering = ordering.drain().flatten().collect::>(); match ordering.len() { 3 => None, 2 => { @@ -357,14 +363,14 @@ impl<'s> From<&'s Position> for Vec<&'s Coordinate> { fn from(position: &'s Position) -> Self { match position { Position::Position1(coordinate) => vec![coordinate], - Position::Position2(coordinates) => coordinates.iter().map(|c| c).collect(), - Position::Position3(coordinates) => coordinates.iter().map(|c| c).collect(), - Position::Position4(coordinates) => coordinates.iter().map(|c| c).collect(), - Position::Position5(coordinates) => coordinates.iter().map(|c| c).collect(), - Position::Position6(coordinates) => coordinates.iter().map(|c| c).collect(), - Position::Position7(coordinates) => coordinates.iter().map(|c| c).collect(), - Position::Position8(coordinates) => coordinates.iter().map(|c| c).collect(), - Position::PositionN(coordinates) => coordinates.iter().map(|c| c).collect(), + Position::Position2(coordinates) => coordinates.iter().collect(), + Position::Position3(coordinates) => coordinates.iter().collect(), + Position::Position4(coordinates) => coordinates.iter().collect(), + Position::Position5(coordinates) => coordinates.iter().collect(), + Position::Position6(coordinates) => coordinates.iter().collect(), + Position::Position7(coordinates) => coordinates.iter().collect(), + Position::Position8(coordinates) => coordinates.iter().collect(), + Position::PositionN(coordinates) => coordinates.iter().collect(), } } } diff --git a/src/database/space/shape.rs b/src/database/space/shape.rs index 76ea088..2906b5c 100644 --- a/src/database/space/shape.rs +++ b/src/database/space/shape.rs @@ -276,7 +276,7 @@ impl Shape { /// Compute the volume. pub fn volume(&self) -> f64 { match self { - Shape::Point(_) => std::f64::EPSILON, // Smallest non-zero volume possible + Shape::Point(_) => f64::EPSILON, // Smallest non-zero volume possible Shape::BoundingBox(low, high) => { let mut volume = 1.0; diff --git a/src/database/space_db.rs b/src/database/space_db.rs index c4f4750..4e561b9 100644 --- a/src/database/space_db.rs +++ b/src/database/space_db.rs @@ -1,6 +1,7 @@ use std::cmp::Ordering; use std::collections::hash_map::DefaultHasher; use std::collections::HashMap; +use std::convert::TryInto; use std::hash::Hash; use std::hash::Hasher; @@ -79,7 +80,7 @@ impl SpaceDB { .collect(); // Make sure we do not shift more position than available - let shift = if count >= 31 { 31 } else { count as u32 }; + let shift: u32 = if count >= 31 { 31 } else { count.try_into().unwrap() }; indices.push(( SpaceSetIndex::new(space_objects.iter(), DIMENSIONS, CELL_BITS), vec![power.0, power.0, power.0], diff --git a/src/database/space_index.rs b/src/database/space_index.rs index 3b6b1f4..8d1da85 100644 --- a/src/database/space_index.rs +++ b/src/database/space_index.rs @@ -218,7 +218,7 @@ impl SpaceIndex { // then add the condition of the radius as we are working within // a sphere. let results = self - .find_range(&lower, &higher) + .find_range(lower, higher) .filter(move |(position, _)| (position - ¢er).norm() <= radius.f64()); Ok(Box::new(results)) diff --git a/src/storage/model.rs b/src/storage/model.rs index d35bd2b..7c55b14 100644 --- a/src/storage/model.rs +++ b/src/storage/model.rs @@ -220,13 +220,13 @@ pub mod v2 { pub fn from_spaces_by_properties<'o>( objects: Box< (dyn Iterator< - Item = ( + Item=( &'o database::Properties, - Vec<(&'o String, Box + 'o>)>, + Vec<(&'o String, Box + 'o>)>, ), > + 'o), >, - ) -> impl Iterator + 'o { + ) -> impl Iterator + 'o { objects.map(|(property, positions_by_spaces)| { let volumes = positions_by_spaces .into_iter() @@ -234,13 +234,10 @@ pub mod v2 { // We are not using vec![] as we now beforehand we // will have only one element in the vector, so we // optimise for space by allocating it as such. - let mut shapes = Vec::with_capacity(1); - - shapes.push(Shape::Points( - positions - .map(|position| position.into()) - .collect::>(), - )); + let shapes = vec![ + Shape::Points(positions.map(|position| + position.into()).collect::>()) + ]; Volume { space: space.clone(), @@ -263,9 +260,9 @@ pub mod v2 { /// /// * `list`: /// A list of (**Space Id**, [ ( *Spatial position*, `&Properties` ) ]) tuples. - pub fn from_properties_by_spaces<'o>( - objects: database::IterObjectsBySpaces<'o>, - ) -> impl Iterator + 'o { + pub fn from_properties_by_spaces( + objects: database::IterObjectsBySpaces<'_>, + ) -> impl Iterator + '_ { // Filter per Properties, in order to regroup by it, then build // a single SpatialObject per Properties. let mut hashmap = HashMap::new(); diff --git a/src/storage/xyz.rs b/src/storage/xyz.rs index 0ea6a0e..a1726ac 100644 --- a/src/storage/xyz.rs +++ b/src/storage/xyz.rs @@ -180,7 +180,9 @@ fn convert(string: &str) -> Result, Error> { let (x, y, z) = (x - origin[0], y - origin[1], z - origin[2]); let (x, y, z) = (x * 0.039_062_5, y * 0.039_062_5, z * 0.039_062_5); - oids.entry(oid).or_insert_with(Vec::new).push(vec![x, y, z]); + oids.entry(oid) + .or_insert_with(Vec::new) + .push(vec![x, y, z]); } } _ => trace!("line {:?}, values: {:?}", line, values),