remove generic parameter in link

WIP: Tests are not fixed yet

Author: Janekdererste

src/simulation/controller.rs

@@ -6,7 +6,6 @@ use crate::simulation::io::proto_events::ProtoEventsWriter;
 use crate::simulation::io::vehicle_definitions::{IOVehicleDefinitions, VehicleDefinitions};
 use crate::simulation::messaging::events::EventsPublisher;
 use crate::simulation::messaging::message_broker::MpiMessageBroker;
-use crate::simulation::messaging::messages::proto::Vehicle;
 use crate::simulation::messaging::travel_time_collector::TravelTimeCollector;
 use crate::simulation::network::network::Network;
 use crate::simulation::partition_info::PartitionInfo;
@@ -38,7 +37,7 @@ pub fn run(world: SystemCommunicator, config: Config) {
     let io_population = IOPopulation::from_file(config.population_file.as_ref());
     let id_mappings = MatsimIdMappings::from_io(&io_network, &io_population);
     let partition_info = PartitionInfo::from_io_network(&io_network, &id_mappings, size as usize);
-    let mut network: Network<Vehicle> = Network::from_io(
+    let mut network: Network = Network::from_io(
         &io_network,
         size as usize,
         config.sample_size,

src/simulation/io/network.rs

@@ -2,7 +2,6 @@ use crate::simulation::id_mapping::MatsimIdMapping;
 use crate::simulation::io::matsim_id::MatsimId;
 use crate::simulation::io::xml_reader;
 use crate::simulation::network::network::Network;
-use crate::simulation::network::node::NodeVehicle;
 use flate2::Compression;
 use log::info;
 use quick_xml::se::to_writer;
@@ -154,9 +153,9 @@ impl IONetwork {
         info!("IONetwork: Finished writing network.");
     }
 
-    pub fn clone_with_internal_ids<V: NodeVehicle>(
+    pub fn clone_with_internal_ids(
         &self,
-        network: &Network<V>,
+        network: &Network,
         link_id_mapping: &MatsimIdMapping,
         node_id_mapping: &MatsimIdMapping,
     ) -> IONetwork {

src/simulation/network/link.rs

@@ -1,19 +1,20 @@
 use crate::simulation::io::network::IOLink;
 use crate::simulation::io::vehicle_definitions::VehicleDefinitions;
+use crate::simulation::messaging::messages::proto::Vehicle;
 use crate::simulation::network::flow_cap::Flowcap;
 use crate::simulation::network::node::NodeVehicle;
 use log::warn;
 use std::collections::VecDeque;
 use std::fmt::Debug;
 
 #[derive(Debug, Clone)]
-pub enum Link<V: Debug> {
-    LocalLink(LocalLink<V>),
-    SplitInLink(SplitInLink<V>),
+pub enum Link {
+    LocalLink(LocalLink),
+    SplitInLink(SplitInLink),
     SplitOutLink(SplitOutLink),
 }
 
-impl<V: NodeVehicle> Link<V> {
+impl Link {
     pub fn from_to_id(&self) -> (usize, usize) {
         (self.from_id(), self.to_id())
     }
@@ -40,9 +41,9 @@ impl<V: NodeVehicle> Link<V> {
 }
 
 #[derive(Debug, Clone)]
-pub struct LocalLink<V: Debug> {
+pub struct LocalLink {
     id: usize,
-    q: VecDeque<VehicleQEntry<V>>,
+    q: VecDeque<VehicleQEntry<Vehicle>>,
     length: f32,
     freespeed: f32,
     flowcap: Flowcap,
@@ -57,7 +58,7 @@ struct VehicleQEntry<V> {
     earliest_exit_time: u32,
 }
 
-impl<V: Debug + NodeVehicle> LocalLink<V> {
+impl LocalLink {
     pub fn from_io_link(
         id: usize,
         link: &IOLink,
@@ -101,7 +102,7 @@ impl<V: Debug + NodeVehicle> LocalLink<V> {
 
     pub fn push_vehicle(
         &mut self,
-        vehicle: V,
+        vehicle: Vehicle,
         now: u32,
         vehicle_definitions: Option<&VehicleDefinitions>,
     ) {
@@ -114,7 +115,7 @@ impl<V: Debug + NodeVehicle> LocalLink<V> {
         });
     }
 
-    pub fn pop_front(&mut self, now: u32) -> Vec<V> {
+    pub fn pop_front(&mut self, now: u32) -> Vec<Vehicle> {
         self.flowcap.update_capacity(now);
 
         let mut popped_veh = Vec::new();
@@ -146,7 +147,7 @@ impl<V: Debug + NodeVehicle> LocalLink<V> {
 
     fn get_speed_for_vehicle(
         &self,
-        vehicle: &V,
+        vehicle: &Vehicle,
         vehicle_definitions: Option<&VehicleDefinitions>,
     ) -> f32 {
         if vehicle_definitions.is_none() {
@@ -190,13 +191,13 @@ impl SplitOutLink {
 }
 
 #[derive(Debug, Clone)]
-pub struct SplitInLink<V: Debug> {
+pub struct SplitInLink {
     from_part: usize,
-    local_link: LocalLink<V>,
+    local_link: LocalLink,
 }
 
-impl<V: Debug> SplitInLink<V> {
-    pub fn new(from_part: usize, local_link: LocalLink<V>) -> Self {
+impl SplitInLink {
+    pub fn new(from_part: usize, local_link: LocalLink) -> Self {
         SplitInLink {
             from_part,
             local_link,
@@ -207,11 +208,11 @@ impl<V: Debug> SplitInLink<V> {
         self.from_part
     }
 
-    pub fn local_link_mut(&mut self) -> &mut LocalLink<V> {
+    pub fn local_link_mut(&mut self) -> &mut LocalLink {
         &mut self.local_link
     }
 
-    pub fn local_link(&self) -> &LocalLink<V> {
+    pub fn local_link(&self) -> &LocalLink {
         &self.local_link
     }
 }

src/simulation/network/network.rs

@@ -2,26 +2,25 @@ use crate::simulation::id_mapping::MatsimIdMappings;
 use crate::simulation::io::matsim_id::MatsimId;
 use crate::simulation::io::network::{IOLink, IONetwork, IONode};
 use crate::simulation::network::network_partition::NetworkPartition;
-use crate::simulation::network::node::NodeVehicle;
 use std::collections::HashMap;
 use std::fmt::Debug;
 use std::sync::Arc;
 
 #[derive(Debug)]
-pub struct Network<V: NodeVehicle> {
-    pub partitions: Vec<NetworkPartition<V>>,
+pub struct Network {
+    pub partitions: Vec<NetworkPartition>,
     pub nodes_2_partition: Arc<HashMap<usize, usize>>,
     pub links_2_partition: Arc<HashMap<usize, usize>>,
 }
 
-pub struct MutNetwork<V: NodeVehicle> {
-    pub partitions: Vec<NetworkPartition<V>>,
+pub struct MutNetwork {
+    pub partitions: Vec<NetworkPartition>,
     pub nodes_2_partition: HashMap<usize, usize>,
     pub links_2_partition: HashMap<usize, usize>,
 }
 
-impl<V: NodeVehicle> Network<V> {
-    fn from_mut_network(network: MutNetwork<V>) -> Self {
+impl Network {
+    fn from_mut_network(network: MutNetwork) -> Self {
         Network {
             partitions: network.partitions,
             nodes_2_partition: Arc::new(network.nodes_2_partition),
@@ -61,7 +60,7 @@ impl<V: NodeVehicle> Network<V> {
     }
 }
 
-impl<V: NodeVehicle> MutNetwork<V> {
+impl MutNetwork {
     fn new(num_parts: usize) -> Self {
         let mut partitions = Vec::with_capacity(num_parts);
         for _ in 0..num_parts {

src/simulation/network/network_partition.rs

@@ -1,17 +1,17 @@
 use crate::simulation::io::network::IOLink;
 use crate::simulation::network::link::{Link, LocalLink, SplitInLink, SplitOutLink};
-use crate::simulation::network::node::{Node, NodeVehicle};
+use crate::simulation::network::node::{Node};
 use std::collections::btree_map::Values;
 use std::collections::{BTreeMap, HashSet};
 use std::fmt::Debug;
 
 #[derive(Debug, Clone)]
-pub struct NetworkPartition<V: NodeVehicle> {
-    pub links: BTreeMap<usize, Link<V>>,
+pub struct NetworkPartition {
+    pub links: BTreeMap<usize, Link>,
     pub nodes: BTreeMap<usize, Node>,
 }
 
-impl<V: NodeVehicle> NetworkPartition<V> {
+impl NetworkPartition {
     pub fn new() -> Self {
         Self {
             links: BTreeMap::new(),

src/simulation/network/node.rs

@@ -1,6 +1,7 @@
 use crate::simulation::io::vehicle_definitions::VehicleDefinitions;
 use crate::simulation::messaging::events::proto::Event;
 use crate::simulation::messaging::events::EventsPublisher;
+use crate::simulation::messaging::messages::proto::Vehicle;
 use crate::simulation::network::link::Link;
 use crate::simulation::network::node::Node::{LocalNode, NeighbourNode};
 use std::collections::BTreeMap;
@@ -61,13 +62,13 @@ impl Node {
         }
     }
 
-    pub fn move_vehicles<V: NodeVehicle>(
+    pub fn move_vehicles(
         &self,
-        links: &mut BTreeMap<usize, Link<V>>,
+        links: &mut BTreeMap<usize, Link>,
         now: u32,
         events: &mut EventsPublisher,
         vehicle_definitions: Option<&VehicleDefinitions>,
-    ) -> Vec<ExitReason<V>> {
+    ) -> Vec<ExitReason> {
         match self {
             LocalNode(n) => n.move_vehicles(links, now, events, vehicle_definitions),
             NeighbourNode(_) => {
@@ -102,9 +103,9 @@ pub struct NodeImpl {
     pub y: f32,
 }
 
-pub enum ExitReason<V> {
-    FinishRoute(V),
-    ReachedBoundary(V),
+pub enum ExitReason {
+    FinishRoute(Vehicle),
+    ReachedBoundary(Vehicle),
 }
 
 impl NodeImpl {
@@ -126,17 +127,17 @@ impl NodeImpl {
         self.out_links.push(id);
     }
 
-    pub fn move_vehicles<V: NodeVehicle>(
+    pub fn move_vehicles(
         &self,
-        links: &mut BTreeMap<usize, Link<V>>,
+        links: &mut BTreeMap<usize, Link>,
         now: u32,
         events: &mut EventsPublisher,
         vehicle_definitions: Option<&VehicleDefinitions>,
-    ) -> Vec<ExitReason<V>> {
+    ) -> Vec<ExitReason> {
         let mut exited_vehicles = Vec::new();
 
         for in_link_index in &self.in_links {
-            let vehicles: Vec<V> = match links.get_mut(in_link_index).unwrap() {
+            let vehicles: Vec<Vehicle> = match links.get_mut(in_link_index).unwrap() {
                 Link::LocalLink(link) => link.pop_front(now),
                 Link::SplitInLink(split_link) => split_link.local_link_mut().pop_front(now),
                 Link::SplitOutLink(_) => panic!("No split out link expected as in link of a node."),
@@ -170,12 +171,12 @@ impl NodeImpl {
         exited_vehicles
     }
 
-    fn move_vehicle<V: NodeVehicle>(
+    fn move_vehicle(
         &self,
-        links: &mut BTreeMap<usize, Link<V>>,
+        links: &mut BTreeMap<usize, Link>,
         out_link_id: usize,
-        vehicle: V,
-        exited_vehicles: &mut Vec<ExitReason<V>>,
+        vehicle: Vehicle,
+        exited_vehicles: &mut Vec<ExitReason>,
         now: u32,
         events: &mut EventsPublisher,
         vehicle_definitions: Option<&VehicleDefinitions>,

src/simulation/population.rs

@@ -3,7 +3,6 @@ use crate::simulation::id_mapping::{MatsimIdMapping, MatsimIdMappings};
 use crate::simulation::io::population::{IOPerson, IOPlanElement, IOPopulation};
 use crate::simulation::messaging::messages::proto::Agent;
 use crate::simulation::network::network::Network;
-use crate::simulation::network::node::NodeVehicle;
 use std::collections::btree_map::BTreeMap;
 
 #[derive(Debug)]
@@ -20,11 +19,11 @@ impl Population {
         }
     }
 
-    pub fn from_io<V: NodeVehicle>(
+    pub fn from_io(
         io_population: &IOPopulation,
         id_mappings: &MatsimIdMappings,
         partition: usize,
-        network: &Network<V>,
+        network: &Network,
         routing_mode: RoutingMode,
     ) -> Population {
         let mut result = Population::new();

src/simulation/routing/walk_leg_updater.rs

@@ -1,9 +1,9 @@
-use crate::simulation::messaging::messages::proto::{Activity, Agent, Vehicle};
+use crate::simulation::messaging::messages::proto::{Activity, Agent};
 use crate::simulation::network::network_partition::NetworkPartition;
 use geo::{Closest, ClosestPoint, EuclideanDistance, Line, Point};
 
 pub trait WalkLegUpdater {
-    fn update_walk_leg(&self, agent: &mut Agent, network: &NetworkPartition<Vehicle>);
+    fn update_walk_leg(&self, agent: &mut Agent, network: &NetworkPartition);
 }
 
 pub struct EuclideanWalkLegUpdater {
@@ -17,7 +17,7 @@ impl EuclideanWalkLegUpdater {
         }
     }
 
-    fn get_walk_distance(&self, curr_act: &Activity, network: &NetworkPartition<Vehicle>) -> f32 {
+    fn get_walk_distance(&self, curr_act: &Activity, network: &NetworkPartition) -> f32 {
         let curr_act_point = Point::new(curr_act.x, curr_act.y);
         let (from_node_id, to_node_id) = network
             .links
@@ -47,7 +47,7 @@ impl EuclideanWalkLegUpdater {
 }
 
 impl WalkLegUpdater for EuclideanWalkLegUpdater {
-    fn update_walk_leg(&self, agent: &mut Agent, network: &NetworkPartition<Vehicle>) {
+    fn update_walk_leg(&self, agent: &mut Agent, network: &NetworkPartition) {
         let curr_act = agent.curr_act();
         let next_act = agent.next_act();
 

src/simulation/simulation.rs

@@ -20,7 +20,7 @@ use log::{debug, info};
 pub struct Simulation<'sim> {
     activity_q: TimeQueue<Agent>,
     teleportation_q: TimeQueue<Vehicle>,
-    network: NetworkPartition<Vehicle>,
+    network: NetworkPartition,
     message_broker: MpiMessageBroker,
     events: EventsPublisher,
     router: Option<Box<dyn Router>>,
@@ -33,7 +33,7 @@ impl<'sim> Simulation<'sim> {
     pub fn new(
         config: &Config,
         id_mappings: &'sim MatsimIdMappings,
-        network: NetworkPartition<Vehicle>,
+        network: NetworkPartition,
         population: Population,
         message_broker: MpiMessageBroker,
         events: EventsPublisher,
@@ -263,7 +263,7 @@ impl<'sim> Simulation<'sim> {
     }
 
     fn move_nodes(&mut self, now: u32) {
-        for node in NetworkPartition::<Vehicle>::get_local_nodes(self.network.nodes.values()) {
+        for node in NetworkPartition::get_local_nodes(self.network.nodes.values()) {
             let exited_vehicles = node.move_vehicles(
                 &mut self.network.links,
                 now,