Adjust code style

Author: reinterpretcat

.rustfmt.toml

@@ -1 +1,3 @@
-max_width=120
+max_width=120
+use_small_heuristics="Max"
+# fn_single_line=true

src/construction/constraints/pipeline.rs

@@ -127,9 +127,7 @@ impl ConstraintPipeline {
     /// Checks whether all hard route constraints are fulfilled.
     /// Returns result of first failed constraint or empty value.
     pub fn evaluate_hard_route(&self, ctx: &RouteContext, job: &Arc<Job>) -> Option<RouteConstraintViolation> {
-        self.hard_route_constraints
-            .iter()
-            .find_map(|c| c.evaluate_job(ctx, job))
+        self.hard_route_constraints.iter().find_map(|c| c.evaluate_job(ctx, job))
     }
 
     /// Checks whether all activity route constraints are fulfilled.
@@ -139,24 +137,16 @@ impl ConstraintPipeline {
         route_ctx: &RouteContext,
         activity_ctx: &ActivityContext,
     ) -> Option<ActivityConstraintViolation> {
-        self.hard_activity_constraints
-            .iter()
-            .find_map(|c| c.evaluate_activity(route_ctx, activity_ctx))
+        self.hard_activity_constraints.iter().find_map(|c| c.evaluate_activity(route_ctx, activity_ctx))
     }
 
     /// Checks soft route constraints and aggregates associated actual and penalty costs.
     pub fn evaluate_soft_route(&self, ctx: &RouteContext, job: &Arc<Job>) -> Cost {
-        self.soft_route_constraints
-            .iter()
-            .map(|c| c.estimate_job(ctx, job))
-            .sum()
+        self.soft_route_constraints.iter().map(|c| c.estimate_job(ctx, job)).sum()
     }
 
     /// Checks soft route constraints and aggregates associated actual and penalty costs.
     pub fn evaluate_soft_activity(&self, route_ctx: &RouteContext, activity_ctx: &ActivityContext) -> Cost {
-        self.soft_activity_constraints
-            .iter()
-            .map(|c| c.estimate_activity(route_ctx, activity_ctx))
-            .sum()
+        self.soft_activity_constraints.iter().map(|c| c.estimate_activity(route_ctx, activity_ctx)).sum()
     }
 }

src/construction/constraints/timing.rs

@@ -39,10 +39,7 @@ impl ConstraintModule for TimingConstraintModule {
             |(loc, dep), activity| {
                 let mut a = activity.write().unwrap();
 
-                a.schedule.arrival = dep
-                    + self
-                        .transport
-                        .duration(actor.vehicle.profile, loc, a.place.location, dep);
+                a.schedule.arrival = dep + self.transport.duration(actor.vehicle.profile, loc, a.place.location, dep);
 
                 a.schedule.departure = a.schedule.arrival.max(a.place.time.start)
                     + self.activity.duration(
@@ -59,10 +56,7 @@ impl ConstraintModule for TimingConstraintModule {
         // update latest arrival and waiting states of non-terminate (jobs) activities
         let init = (
             actor.detail.time.end,
-            actor
-                .detail
-                .end
-                .unwrap_or(actor.detail.start.unwrap_or(panic!(OP_START_MSG))),
+            actor.detail.end.unwrap_or(actor.detail.start.unwrap_or(panic!(OP_START_MSG))),
             0f64,
         );
         route.tour.all_activities().rev().fold(init, |acc, activity| {
@@ -73,12 +67,8 @@ impl ConstraintModule for TimingConstraintModule {
 
             let (end_time, prev_loc, waiting) = acc;
             let potential_latest = end_time
-                - self
-                    .transport
-                    .duration(actor.vehicle.profile, act.place.location, prev_loc, end_time)
-                - self
-                    .activity
-                    .duration(actor.vehicle.as_ref(), actor.driver.as_ref(), act.deref(), end_time);
+                - self.transport.duration(actor.vehicle.profile, act.place.location, prev_loc, end_time)
+                - self.activity.duration(actor.vehicle.as_ref(), actor.driver.as_ref(), act.deref(), end_time);
 
             let latest_arrival_time = act.place.time.end.min(potential_latest);
             let future_waiting = waiting + (act.place.time.start - act.schedule.arrival).max(0f64);
@@ -137,17 +127,11 @@ struct TimeHardActivityConstraint {
 
 impl TimeHardActivityConstraint {
     fn fail(&self) -> Option<ActivityConstraintViolation> {
-        Some(ActivityConstraintViolation {
-            code: self.code,
-            stopped: true,
-        })
+        Some(ActivityConstraintViolation { code: self.code, stopped: true })
     }
 
     fn stop(&self) -> Option<ActivityConstraintViolation> {
-        Some(ActivityConstraintViolation {
-            code: self.code,
-            stopped: false,
-        })
+        Some(ActivityConstraintViolation { code: self.code, stopped: false })
     }
 
     fn success(&self) -> Option<ActivityConstraintViolation> {
@@ -173,9 +157,7 @@ impl HardActivityConstraint for TimeHardActivityConstraint {
 
         if actor.detail.time.end < prev.place.time.start
             || actor.detail.time.end < target.place.time.start
-            || next.map_or(false, |next| {
-                actor.detail.time.end < next.read().unwrap().place.time.start
-            })
+            || next.map_or(false, |next| actor.detail.time.end < next.read().unwrap().place.time.start)
         {
             return self.fail();
         }
@@ -190,30 +172,24 @@ impl HardActivityConstraint for TimeHardActivityConstraint {
             }
             (
                 n.place.location,
-                *state
-                    .get_activity_state(LATEST_ARRIVAL_KEY, next.unwrap())
-                    .unwrap_or(&n.place.time.end),
+                *state.get_activity_state(LATEST_ARRIVAL_KEY, next.unwrap()).unwrap_or(&n.place.time.end),
             )
         } else {
             // open vrp
             (target.place.location, target.place.time.end.min(actor.detail.time.end))
         };
 
-        let arr_time_at_next = departure
-            + self
-                .transport
-                .duration(profile, prev.place.location, next_act_location, departure);
+        let arr_time_at_next =
+            departure + self.transport.duration(profile, prev.place.location, next_act_location, departure);
         if arr_time_at_next > latest_arr_time_at_next_act {
             return self.fail();
         }
         if target.place.time.start > latest_arr_time_at_next_act {
             return self.stop();
         }
 
-        let arr_time_at_target_act = departure
-            + self
-                .transport
-                .duration(profile, prev.place.location, target.place.location, departure);
+        let arr_time_at_target_act =
+            departure + self.transport.duration(profile, prev.place.location, target.place.location, departure);
 
         let end_time_at_new_act = arr_time_at_target_act.max(target.place.time.start)
             + self.activity.duration(
@@ -248,9 +224,7 @@ impl HardActivityConstraint for TimeHardActivityConstraint {
         }
 
         let arr_time_at_next_act = end_time_at_new_act
-            + self
-                .transport
-                .duration(profile, target.place.location, next_act_location, end_time_at_new_act);
+            + self.transport.duration(profile, target.place.location, next_act_location, end_time_at_new_act);
 
         if arr_time_at_next_act > latest_arr_time_at_next_act {
             self.stop()

src/construction/heuristics/evaluators.rs

@@ -20,12 +20,9 @@ impl InsertionEvaluator {
 
     /// Evaluates possibility to preform insertion from given insertion context.
     pub fn evaluate(&self, job: &Arc<Job>, ctx: &InsertionContext) -> InsertionResult {
-        ctx.solution
-            .routes
-            .iter()
-            .cloned()
-            .chain(ctx.solution.registry.next().map(|a| RouteContext::new(a)))
-            .fold(InsertionResult::make_failure(), |acc, route_ctx| {
+        ctx.solution.routes.iter().cloned().chain(ctx.solution.registry.next().map(|a| RouteContext::new(a))).fold(
+            InsertionResult::make_failure(),
+            |acc, route_ctx| {
                 if let Some(violation) = ctx.problem.constraint.evaluate_hard_route(&route_ctx, job) {
                     return InsertionResult::choose_best_result(
                         acc,
@@ -49,7 +46,8 @@ impl InsertionEvaluator {
                         Job::Multi(multi) => Self::evaluate_multi(job, multi, ctx, &route_ctx, &progress),
                     },
                 )
-            })
+            },
+        )
     }
 
     fn evaluate_single(
@@ -71,22 +69,15 @@ impl InsertionEvaluator {
                     _ => panic!("Unexpected route leg configuration."),
                 };
 
-                let mut activity_ctx = ActivityContext {
-                    index,
-                    prev,
-                    target: activity.clone(),
-                    next: Some(next),
-                };
+                let mut activity_ctx = ActivityContext { index, prev, target: activity.clone(), next: Some(next) };
 
                 // 2. analyze service details
                 single.places.iter().try_fold(out, |in1, detail| {
                     // TODO check whether tw is empty
                     // 3. analyze detail time windows
                     detail.times.iter().try_fold(in1, |in2, time| {
                         activity.write().unwrap().place = Place {
-                            location: detail
-                                .location
-                                .unwrap_or(activity_ctx.prev.read().unwrap().place.location),
+                            location: detail.location.unwrap_or(activity_ctx.prev.read().unwrap().place.location),
                             duration: detail.duration,
                             time: time.clone(),
                         };
@@ -118,12 +109,7 @@ impl InsertionEvaluator {
 
         if result.is_success() {
             activity.write().unwrap().place = result.place;
-            InsertionResult::make_success(
-                result.cost,
-                job.clone(),
-                vec![(activity, result.index)],
-                route_ctx.clone(),
-            )
+            InsertionResult::make_success(result.cost, job.clone(), vec![(activity, result.index)], route_ctx.clone())
         } else {
             InsertionResult::make_failure_with_code(result.violation.unwrap().code)
         }
@@ -159,22 +145,13 @@ impl SingleContext {
             violation: None,
             index: 0,
             cost,
-            place: Place {
-                location: 0,
-                duration: 0.0,
-                time: TimeWindow { start: 0.0, end: 0.0 },
-            },
+            place: Place { location: 0, duration: 0.0, time: TimeWindow { start: 0.0, end: 0.0 } },
         }
     }
 
     fn fail(violation: ActivityConstraintViolation, other: SingleContext) -> Result<Self, Self> {
         let stopped = violation.stopped;
-        let ctx = Self {
-            violation: Some(violation),
-            index: other.index,
-            cost: other.cost,
-            place: other.place,
-        };
+        let ctx = Self { violation: Some(violation), index: other.index, cost: other.cost, place: other.place };
         if stopped {
             Result::Err(ctx)
         } else {
@@ -183,12 +160,7 @@ impl SingleContext {
     }
 
     fn success(index: usize, cost: Cost, place: Place) -> Result<Self, Self> {
-        Result::Ok(Self {
-            violation: None,
-            index,
-            cost,
-            place,
-        })
+        Result::Ok(Self { violation: None, index, cost, place })
     }
 
     fn skip(other: SingleContext) -> Result<Self, Self> {

src/construction/states/models.rs

@@ -113,12 +113,7 @@ impl InsertionResult {
         activities: Vec<(TourActivity, usize)>,
         route_ctx: RouteContext,
     ) -> Self {
-        Self::Success(InsertionSuccess {
-            cost,
-            job,
-            activities,
-            context: route_ctx,
-        })
+        Self::Success(InsertionSuccess { cost, job, activities, context: route_ctx })
     }
 
     /// Creates result which represents insertion failure.
@@ -163,39 +158,20 @@ impl RouteContext {
     fn create_start_activity(actor: &Arc<Actor>) -> TourActivity {
         Arc::new(RwLock::new(Activity {
             place: Place {
-                location: actor
-                    .detail
-                    .start
-                    .unwrap_or_else(|| unimplemented!("Optional start is not yet implemented")),
+                location: actor.detail.start.unwrap_or_else(|| unimplemented!("Optional start is not yet implemented")),
                 duration: 0.0,
-                time: TimeWindow {
-                    start: actor.detail.time.start,
-                    end: std::f64::MAX,
-                },
-            },
-            schedule: Schedule {
-                arrival: actor.detail.time.start,
-                departure: actor.detail.time.start,
+                time: TimeWindow { start: actor.detail.time.start, end: std::f64::MAX },
             },
+            schedule: Schedule { arrival: actor.detail.time.start, departure: actor.detail.time.start },
             job: None,
         }))
     }
 
     fn create_end_activity(actor: &Arc<Actor>) -> Option<TourActivity> {
         actor.detail.end.map(|location| {
             Arc::new(RwLock::new(Activity {
-                place: Place {
-                    location,
-                    duration: 0.0,
-                    time: TimeWindow {
-                        start: 0.0,
-                        end: actor.detail.time.end,
-                    },
-                },
-                schedule: Schedule {
-                    arrival: actor.detail.time.end,
-                    departure: actor.detail.time.end,
-                },
+                place: Place { location, duration: 0.0, time: TimeWindow { start: 0.0, end: actor.detail.time.end } },
+                schedule: Schedule { arrival: actor.detail.time.end, departure: actor.detail.time.end },
                 job: None,
             }))
         })

src/construction/states/route.rs

@@ -40,9 +40,7 @@ impl RouteState {
 
     /// Gets value associated with key.
     pub fn get_activity_state<T: 'static>(&self, key: i32, activity: &TourActivity) -> Option<&T> {
-        self.activity_states
-            .get(&ActivityWithKey(activity.clone(), key))
-            .and_then(|s| s.downcast_ref::<T>())
+        self.activity_states.get(&ActivityWithKey(activity.clone(), key)).and_then(|s| s.downcast_ref::<T>())
     }
 
     /// Puts value associated with key.
@@ -53,8 +51,7 @@ impl RouteState {
 
     /// Puts value associated with key and specific activity.
     pub fn put_activity_state<T: 'static>(&mut self, key: i32, activity: &TourActivity, value: T) {
-        self.activity_states
-            .insert(ActivityWithKey(activity.clone(), key), Box::new(value));
+        self.activity_states.insert(ActivityWithKey(activity.clone(), key), Box::new(value));
         self.keys.insert(key);
     }
 

src/models/problem/costs.rs

@@ -7,11 +7,7 @@ use crate::models::solution::Activity;
 pub trait ActivityCost {
     /// Returns cost to perform activity.
     fn cost(&self, vehicle: &Vehicle, driver: &Driver, activity: &Activity, arrival: Timestamp) -> Cost {
-        let waiting = if activity.place.time.start > arrival {
-            activity.place.time.start - arrival
-        } else {
-            0.0
-        };
+        let waiting = if activity.place.time.start > arrival { activity.place.time.start - arrival } else { 0.0 };
         let service = self.duration(vehicle, driver, activity, arrival);
 
         waiting * (driver.costs.per_waiting_time + vehicle.costs.per_waiting_time)
@@ -59,30 +55,16 @@ impl MatrixTransportCost {
         assert!(distances.iter().all(|d| (d.len() as f64).sqrt() as usize == size));
         assert!(durations.iter().all(|d| (d.len() as f64).sqrt() as usize == size));
 
-        MatrixTransportCost {
-            durations,
-            distances,
-            size,
-        }
+        MatrixTransportCost { durations, distances, size }
     }
 }
 
 impl TransportCost for MatrixTransportCost {
     fn duration(&self, profile: Profile, from: Location, to: Location, departure: Timestamp) -> Duration {
-        self.durations
-            .get(profile as usize)
-            .unwrap()
-            .get(from * self.size + to)
-            .unwrap()
-            .clone()
+        self.durations.get(profile as usize).unwrap().get(from * self.size + to).unwrap().clone()
     }
 
     fn distance(&self, profile: Profile, from: Location, to: Location, departure: Timestamp) -> Distance {
-        self.distances
-            .get(profile as usize)
-            .unwrap()
-            .get(from * self.size + to)
-            .unwrap()
-            .clone()
+        self.distances.get(profile as usize).unwrap().get(from * self.size + to).unwrap().clone()
     }
 }