Remove hashbrown dependency

CHANGELOG.md

@@ -14,6 +14,7 @@ are already published. So, I stick to it for now.
 * GitHub sponsors functionality
 * experimental `async-evolution` feature
 * NSGA-II implementation and its usage
+* dependency on `hashbrown` crate
 
 ### Fixed
 

Cargo.toml

@@ -32,7 +32,6 @@ vrp-pragmatic = { path = "vrp-pragmatic", version = "1.23.0" }
 vrp-cli = { path = "vrp-cli", version = "1.23.0" }
 
 # external dependencies
-hashbrown = "0.14.5"
 serde = { version = "1.0.202", features = ["derive"] }
 serde_json = "1.0.117"
 rand = { version = "0.8.5", features = ["small_rng"] }

vrp-core/Cargo.toml

@@ -16,7 +16,6 @@ rosomaxa.workspace = true
 
 rand.workspace = true
 rayon.workspace = true
-hashbrown.workspace = true
 rustc-hash.workspace = true
 
 nohash-hasher = "0.2.0"

vrp-core/src/algorithms/clustering/dbscan.rs

@@ -5,7 +5,7 @@
 #[path = "../../../tests/unit/algorithms/clustering/dbscan_test.rs"]
 mod dbscan_test;
 
-use hashbrown::{HashMap, HashSet};
+use std::collections::{HashMap, HashSet};
 use std::hash::Hash;
 
 /// Represents a cluster of points.
@@ -29,7 +29,7 @@ where
     let mut clusters = Vec::new();
 
     for point in points {
-        if point_types.get(point).is_some() {
+        if point_types.contains_key(point) {
             continue;
         }
 

vrp-core/src/construction/clustering/vicinity/estimations.rs

@@ -7,8 +7,8 @@ use crate::models::common::*;
 use crate::models::problem::{Place, Single, TransportCost};
 use crate::models::solution::CommuteInfo;
 use crate::models::GoalContext;
-use hashbrown::{HashMap, HashSet};
 use rosomaxa::utils::parallel_foreach_mut;
+use std::collections::{HashMap, HashSet};
 
 type PlaceInfo = (PlaceIndex, Location, Duration, Vec<TimeWindow>);
 type PlaceIndex = usize;

vrp-core/src/construction/clustering/vicinity/mod.rs

@@ -9,9 +9,9 @@ use crate::models::common::Dimensions;
 use crate::models::common::*;
 use crate::models::problem::{Actor, Job};
 use crate::models::Problem;
-use hashbrown::HashSet;
 use rosomaxa::prelude::*;
 use std::cmp::Ordering;
+use std::collections::HashSet;
 use std::ops::ControlFlow;
 use std::sync::Arc;
 

vrp-core/src/construction/enablers/conditional_job.rs

@@ -1,6 +1,6 @@
 use crate::construction::heuristics::SolutionContext;
 use crate::models::problem::Job;
-use hashbrown::HashSet;
+use std::collections::HashSet;
 
 /// Defines how jobs are moved in solution context. Index of original affected route context is passed.
 pub trait JobContextTransition {

vrp-core/src/construction/enablers/multi_trip.rs

@@ -6,8 +6,8 @@ use crate::construction::heuristics::*;
 use crate::models::problem::Job;
 use crate::models::solution::Route;
 use crate::models::*;
-use hashbrown::HashSet;
 use rosomaxa::prelude::*;
+use std::collections::HashSet;
 use std::iter::once;
 use std::slice::Iter;
 use std::sync::Arc;

vrp-core/src/construction/enablers/reserved_time.rs

@@ -5,9 +5,9 @@ mod reserved_time_test;
 use crate::models::common::*;
 use crate::models::problem::{ActivityCost, Actor, TransportCost, TravelTime};
 use crate::models::solution::{Activity, Route};
-use hashbrown::HashMap;
 use rosomaxa::prelude::{compare_floats, GenericError};
 use std::cmp::Ordering;
+use std::collections::HashMap;
 use std::sync::Arc;
 
 /// Represent a reserved time span entity.

vrp-core/src/construction/enablers/route_intervals.rs

@@ -2,7 +2,7 @@ use crate::construction::heuristics::{RouteContext, SolutionContext, StateKey};
 use crate::models::problem::{Job, Single};
 use crate::models::solution::{Activity, Route};
 use crate::utils::Either;
-use hashbrown::HashSet;
+use std::collections::HashSet;
 use std::iter::once;
 use std::ops::Range;
 use std::sync::Arc;

vrp-core/src/construction/enablers/typed_actor_group_key.rs

@@ -1,5 +1,5 @@
 use crate::models::problem::Actor;
-use hashbrown::{HashMap, HashSet};
+use std::collections::{HashMap, HashSet};
 use std::sync::Arc;
 
 /// An actor group key implementation which creates groups using "type" dimension.

vrp-core/src/construction/features/breaks.rs

@@ -6,7 +6,7 @@ mod breaks_test;
 
 use super::*;
 use crate::construction::enablers::*;
-use hashbrown::HashSet;
+use std::collections::HashSet;
 use std::iter::once;
 
 /// A helper type to work with a break job represented as a reference to `Single` or `Job` types.
@@ -263,16 +263,16 @@ fn remove_invalid_breaks<BA: BreakAspects>(solution_ctx: &mut SolutionContext, a
 
     solution_ctx.unassigned.extend(breaks_to_remove.into_iter().map(|b| (b, UnassignmentInfo::Unknown)));
 
-    // NOTE remove stale breaks from violation list
-    solution_ctx.ignored.extend(
-        solution_ctx
-            .unassigned
-            .extract_if({
-                let routes = solution_ctx.routes.as_slice();
-                move |job, _| !is_required_job(aspects, routes, None, job, true)
-            })
-            .map(|(job, _)| job),
-    );
+    // NOTE remove stale breaks from the violation list
+    solution_ctx.unassigned.retain(|job, _| {
+        let routes = solution_ctx.routes.as_slice();
+        if !is_required_job(aspects, routes, None, job, true) {
+            solution_ctx.ignored.push(job.clone());
+            false
+        } else {
+            true
+        }
+    });
 }
 
 /// Checks whether break can be scheduled in route.

vrp-core/src/construction/features/fast_service.rs

@@ -4,9 +4,9 @@ mod fast_service_test;
 
 use super::*;
 use crate::construction::enablers::{calculate_travel, calculate_travel_delta, RouteIntervals};
-use hashbrown::HashMap;
 use rosomaxa::algorithms::math::relative_distance;
 use std::cmp::Ordering;
+use std::collections::HashMap;
 use std::iter::once;
 
 /// Specifies an aspects needed to use the feature.

vrp-core/src/construction/features/groups.rs

@@ -1,7 +1,7 @@
 //! A feature to model group of jobs.
 
 use super::*;
-use hashbrown::HashSet;
+use std::collections::HashSet;
 
 #[cfg(test)]
 #[path = "../../../tests/unit/construction/features/groups_test.rs"]

vrp-core/src/construction/features/locked_jobs.rs

@@ -7,7 +7,7 @@ mod locked_jobs_test;
 use super::*;
 use crate::models::problem::{Actor, Fleet};
 use crate::models::{Lock, LockOrder, LockPosition};
-use hashbrown::{HashMap, HashSet};
+use std::collections::{HashMap, HashSet};
 use std::sync::Arc;
 
 type ConditionMap = HashMap<Job, Arc<dyn Fn(&Actor) -> bool + Sync + Send>>;

vrp-core/src/construction/features/minimize_unassigned.rs

@@ -42,8 +42,8 @@ impl FeatureObjective for MinimizeUnassignedObjective {
         solution
             .solution
             .unassigned
-            .iter()
-            .map(|(job, _)| (self.unassigned_job_estimator)(&solution.solution, job))
+            .keys()
+            .map(|job| (self.unassigned_job_estimator)(&solution.solution, job))
             .sum::<f64>()
     }
 

vrp-core/src/construction/features/recharge.rs

@@ -8,8 +8,8 @@ mod recharge_test;
 use super::*;
 use crate::construction::enablers::*;
 use crate::models::solution::Route;
-use hashbrown::HashSet;
 use std::cmp::Ordering;
+use std::collections::HashSet;
 use std::iter::once;
 use std::sync::Arc;
 

vrp-core/src/construction/features/reloads.rs

@@ -8,8 +8,8 @@ use super::*;
 use crate::construction::enablers::{FeatureCombinator, RouteIntervals};
 use crate::models::problem::Single;
 use crate::models::solution::Route;
-use hashbrown::HashMap;
 use std::cmp::Ordering;
+use std::collections::HashMap;
 use std::ops::Range;
 
 /// Specifies dependencies needed to use reload feature.

vrp-core/src/construction/features/shared_resource.rs

@@ -8,8 +8,8 @@ use super::*;
 use crate::models::common::{MultiDimLoad, SingleDimLoad};
 use crate::models::problem::Single;
 use crate::models::solution::{Activity, Route};
-use hashbrown::HashMap;
 use std::cmp::Ordering;
+use std::collections::HashMap;
 use std::ops::{Add, RangeInclusive, Sub};
 
 /// Represents a shared unique resource.
@@ -166,7 +166,7 @@ impl<T: SharedResource + Add<Output = T> + Sub<Output = T>> SharedResourceState<
                         .map(|(_, resource_id)| (self.get_total_demand(route_ctx, start_idx..=end_idx), resource_id));
 
                     if let Some((resource_demand, id)) = resource_demand_with_id {
-                        let entry = acc.entry(id).or_insert_with(T::default);
+                        let entry = acc.entry(id).or_default();
                         *entry = *entry + resource_demand;
                     }
 

vrp-core/src/construction/features/skills.rs

@@ -5,7 +5,7 @@
 mod skills_test;
 
 use super::*;
-use hashbrown::HashSet;
+use std::collections::HashSet;
 
 /// Provides a way to work with the job-vehicle skills feature.
 pub trait JobSkillsAspects: Clone + Send + Sync {

vrp-core/src/construction/heuristics/context.rs

@@ -8,11 +8,11 @@ use crate::models::problem::*;
 use crate::models::solution::*;
 use crate::models::{CoreStateKeys, GoalContext};
 use crate::models::{Problem, Solution};
-use hashbrown::{HashMap, HashSet};
 use nohash_hasher::BuildNoHashHasher;
 use rosomaxa::evolution::TelemetryMetrics;
 use rosomaxa::prelude::*;
 use std::any::Any;
+use std::collections::{HashMap, HashSet};
 use std::fmt::{Debug, Formatter};
 use std::ops::Deref;
 use std::sync::Arc;

vrp-core/src/construction/heuristics/factories.rs

@@ -4,8 +4,8 @@ use crate::models::problem::*;
 use crate::models::solution::*;
 use crate::models::OP_START_MSG;
 use crate::models::{LockOrder, Problem, Solution};
-use hashbrown::{HashMap, HashSet};
 use rosomaxa::prelude::Environment;
+use std::collections::{HashMap, HashSet};
 use std::sync::Arc;
 
 type ActivityPlace = crate::models::solution::Place;
@@ -101,7 +101,7 @@ pub fn create_insertion_context(problem: Arc<Problem>, environment: Arc<Environm
     let required = problem
         .jobs
         .all()
-        .filter(|job| locked.get(job).is_none() && reserved.get(job).is_none() && unassigned.get(job).is_none())
+        .filter(|job| !locked.contains(job) && !reserved.contains(job) && !unassigned.contains_key(job))
         .collect();
 
     let registry = RegistryContext::new(problem.goal.as_ref(), registry);

vrp-core/src/construction/heuristics/insertions.rs

@@ -359,7 +359,7 @@ impl TryFrom<InsertionResult> for InsertionSuccess {
 }
 
 pub(crate) fn prepare_insertion_ctx(insertion_ctx: &mut InsertionContext) {
-    insertion_ctx.solution.required.extend(insertion_ctx.solution.unassigned.iter().map(|(job, _)| job.clone()));
+    insertion_ctx.solution.required.extend(insertion_ctx.solution.unassigned.keys().cloned());
     insertion_ctx.problem.goal.accept_solution_state(&mut insertion_ctx.solution);
 }
 

vrp-core/src/construction/probing/repair_solution.rs

@@ -7,9 +7,9 @@ use crate::models::common::TimeSpan;
 use crate::models::problem::{Job, Multi, Single};
 use crate::models::solution::Activity;
 use crate::models::GoalContext;
-use hashbrown::{HashMap, HashSet};
 use rosomaxa::prelude::*;
 use std::cmp::Ordering;
+use std::collections::{HashMap, HashSet};
 use std::ops::ControlFlow;
 use std::sync::Arc;
 

vrp-core/src/models/common/dimens.rs

@@ -1,6 +1,6 @@
-use hashbrown::HashMap;
 use rustc_hash::FxHasher;
 use std::any::{Any, TypeId};
+use std::collections::HashMap;
 use std::hash::BuildHasherDefault;
 use std::sync::Arc;
 

vrp-core/src/models/extras.rs

@@ -2,10 +2,10 @@ use crate::construction::enablers::ScheduleKeys;
 use crate::construction::features::CapacityKeys;
 use crate::construction::heuristics::StateKeyRegistry;
 use crate::solver::HeuristicKeys;
-use hashbrown::HashMap;
 use rosomaxa::prelude::GenericError;
 use rustc_hash::FxHasher;
 use std::any::{Any, TypeId};
+use std::collections::HashMap;
 use std::hash::BuildHasherDefault;
 use std::sync::Arc;
 

vrp-core/src/models/goal.rs

@@ -6,12 +6,12 @@ use crate::construction::enablers::*;
 use crate::construction::heuristics::*;
 use crate::models::common::Cost;
 use crate::models::problem::Job;
-use hashbrown::{HashMap, HashSet};
 use rand::prelude::SliceRandom;
 use rosomaxa::evolution::objectives::dominance_order;
 use rosomaxa::population::Shuffled;
 use rosomaxa::prelude::*;
 use std::cmp::Ordering;
+use std::collections::{HashMap, HashSet};
 use std::fmt::{Debug, Formatter};
 use std::ops::ControlFlow;
 use std::slice::Iter;

vrp-core/src/models/problem/costs.rs

@@ -4,9 +4,9 @@ mod costs_test;
 
 use crate::models::common::*;
 use crate::models::solution::{Activity, Route};
-use hashbrown::HashMap;
 use rosomaxa::prelude::GenericError;
 use rosomaxa::utils::CollectGroupBy;
+use std::collections::HashMap;
 use std::sync::Arc;
 
 /// Specifies travel time type.

vrp-core/src/models/problem/fleet.rs

@@ -4,8 +4,8 @@ mod fleet_test;
 
 use crate::models::common::*;
 use crate::utils::short_type_name;
-use hashbrown::{HashMap, HashSet};
 use std::cmp::Ordering::Less;
+use std::collections::{HashMap, HashSet};
 use std::fmt::{Debug, Formatter};
 use std::hash::{Hash, Hasher};
 use std::sync::Arc;

vrp-core/src/models/problem/jobs.rs

@@ -5,9 +5,9 @@ mod jobs_test;
 use crate::models::common::*;
 use crate::models::problem::{Costs, Fleet, TransportCost};
 use crate::utils::{short_type_name, Either};
-use hashbrown::HashMap;
 use rosomaxa::utils::compare_floats_f32;
 use std::cmp::Ordering::Less;
+use std::collections::HashMap;
 use std::fmt::{Debug, Formatter};
 use std::hash::{Hash, Hasher};
 use std::sync::{Arc, Weak};

vrp-core/src/models/solution/registry.rs

@@ -3,8 +3,8 @@
 mod actor_test;
 
 use crate::models::problem::{Actor, Fleet};
-use hashbrown::{HashMap, HashSet};
 use rosomaxa::prelude::Random;
+use std::collections::{HashMap, HashSet};
 use std::sync::Arc;
 
 /// Specifies an entity responsible for providing actors and keeping track of their usage.

vrp-core/src/models/solution/tour.rs

@@ -7,8 +7,8 @@ use crate::models::problem::{Actor, Job, JobIdDimension};
 use crate::models::solution::{Activity, Place};
 use crate::models::OP_START_MSG;
 use crate::utils::{short_type_name, Either};
-use hashbrown::HashSet;
 use rustc_hash::FxHasher;
+use std::collections::HashSet;
 use std::fmt::{Debug, Formatter};
 use std::hash::BuildHasherDefault;
 use std::iter::once;

vrp-core/src/solver/mod.rs

@@ -76,11 +76,11 @@ extern crate rand;
 use crate::construction::heuristics::InsertionContext;
 use crate::models::{GoalContext, Problem, Solution};
 use crate::solver::search::Recreate;
-use hashbrown::HashMap;
 use rosomaxa::evolution::*;
 use rosomaxa::prelude::*;
 use rosomaxa::{get_default_population, TelemetryHeuristicContext};
 use std::any::Any;
+use std::collections::HashMap;
 use std::sync::Arc;
 
 pub use self::heuristic::*;

vrp-core/src/solver/processing/vicinity_clustering.rs

@@ -9,7 +9,7 @@ use crate::models::problem::Jobs;
 use crate::models::solution::{Activity, Place};
 use crate::models::{Extras, ExtrasBuilder, GoalContext, Problem};
 use crate::solver::RefinementContext;
-use hashbrown::HashSet;
+use std::collections::HashSet;
 use std::sync::Arc;
 
 /// A trait to get or set vicinity config.