#[cfg(test)]
#[path = "../../../tests/unit/models/common/domain_test.rs"]
mod domain_test;
use crate::models::common::{Duration, Timestamp};
use hashbrown::HashMap;
use rosomaxa::prelude::compare_floats;
use rustc_hash::FxHasher;
use std::any::Any;
use std::cmp::Ordering;
use std::hash::{BuildHasherDefault, Hash, Hasher};
use std::sync::Arc;
pub type Location = usize;
#[derive(Clone, Debug)]
pub struct Profile {
pub index: usize,
pub scale: f64,
}
impl Profile {
pub fn new(index: usize, scale: Option<f64>) -> Profile {
Self { index, scale: scale.unwrap_or(1.) }
}
}
impl Default for Profile {
fn default() -> Self {
Self { index: 0, scale: 1. }
}
}
pub type Cost = f64;
#[derive(Clone, Debug)]
pub struct TimeWindow {
pub start: Timestamp,
pub end: Timestamp,
}
#[derive(Clone, Debug)]
pub struct TimeOffset {
pub start: Timestamp,
pub end: Timestamp,
}
#[derive(Clone, Debug)]
pub enum TimeSpan {
Window(TimeWindow),
Offset(TimeOffset),
}
#[derive(Clone, Debug, Default)]
pub struct TimeInterval {
pub earliest: Option<Timestamp>,
pub latest: Option<Timestamp>,
}
impl TimeWindow {
pub fn new(start: Timestamp, end: Timestamp) -> Self {
Self { start, end }
}
pub fn max() -> Self {
Self { start: 0., end: f64::MAX }
}
pub fn intersects(&self, other: &Self) -> bool {
compare_floats(self.start, other.end) != Ordering::Greater
&& compare_floats(other.start, self.end) != Ordering::Greater
}
pub fn intersects_exclusive(&self, other: &Self) -> bool {
compare_floats(self.start, other.end) == Ordering::Less
&& compare_floats(other.start, self.end) == Ordering::Less
}
pub fn contains(&self, time: Timestamp) -> bool {
compare_floats(time, self.start) != Ordering::Less && compare_floats(time, self.end) != Ordering::Greater
}
pub fn distance(&self, other: &Self) -> Timestamp {
if self.intersects(other) {
0.
} else {
if self.start > other.start {
self.start - other.end
} else {
other.start - self.end
}
}
}
pub fn overlapping(&self, other: &Self) -> Option<TimeWindow> {
if self.intersects(other) {
let start = self.start.max(other.start);
let end = self.end.min(other.end);
Some(TimeWindow::new(start, end))
} else {
None
}
}
pub fn duration(&self) -> Duration {
self.end - self.start
}
}
impl PartialEq<TimeWindow> for TimeWindow {
fn eq(&self, other: &TimeWindow) -> bool {
compare_floats(self.start, other.start) == Ordering::Equal
&& compare_floats(self.end, other.end) == Ordering::Equal
}
}
impl Eq for TimeWindow {}
impl Hash for TimeWindow {
fn hash<H: Hasher>(&self, state: &mut H) {
let start = self.start.to_bits() as i64;
let end = self.end.to_bits() as i64;
start.hash(state);
end.hash(state);
}
}
impl TimeOffset {
pub fn new(start: Timestamp, end: Timestamp) -> Self {
Self { start, end }
}
}
impl TimeSpan {
pub fn to_time_window(&self, date: Timestamp) -> TimeWindow {
match &self {
TimeSpan::Window(window) => window.clone(),
TimeSpan::Offset(offset) => TimeWindow::new(date + offset.start, date + offset.end),
}
}
pub fn intersects(&self, date: Timestamp, other: &TimeWindow) -> bool {
self.to_time_window(date).intersects(other)
}
pub fn as_time_window(&self) -> Option<TimeWindow> {
match &self {
TimeSpan::Window(window) => Some(window.clone()),
_ => None,
}
}
}
impl TimeInterval {
pub fn to_time_window(&self) -> TimeWindow {
TimeWindow { start: self.earliest.unwrap_or(0.), end: self.latest.unwrap_or(f64::MAX) }
}
}
#[derive(Clone, Debug)]
pub struct Schedule {
pub arrival: Timestamp,
pub departure: Timestamp,
}
impl Schedule {
pub fn new(arrival: Timestamp, departure: Timestamp) -> Self {
Self { arrival, departure }
}
}
impl PartialEq<Schedule> for Schedule {
fn eq(&self, other: &Schedule) -> bool {
compare_floats(self.arrival, other.arrival) == Ordering::Equal
&& compare_floats(self.departure, other.departure) == Ordering::Equal
}
}
impl Eq for Schedule {}
pub type Dimensions = HashMap<String, Arc<dyn Any + Send + Sync>, BuildHasherDefault<FxHasher>>;
pub trait ValueDimension {
fn get_value<T: 'static>(&self, key: &str) -> Option<&T>;
fn set_value<T: 'static + Sync + Send>(&mut self, key: &str, value: T);
}
impl ValueDimension for Dimensions {
fn get_value<T: 'static>(&self, key: &str) -> Option<&T> {
self.get(key).and_then(|any| any.downcast_ref::<T>())
}
fn set_value<T: 'static + Sync + Send>(&mut self, key: &str, value: T) {
self.insert(key.to_owned(), Arc::new(value));
}
}
pub trait IdDimension {
fn set_id(&mut self, id: &str) -> &mut Self;
fn get_id(&self) -> Option<&String>;
}
impl IdDimension for Dimensions {
fn set_id(&mut self, id: &str) -> &mut Self {
self.set_value("id", id.to_string());
self
}
fn get_id(&self) -> Option<&String> {
self.get_value("id")
}
}
impl Hash for TimeInterval {
fn hash<H: Hasher>(&self, state: &mut H) {
let earliest = self.earliest.unwrap_or(0.).to_bits() as i64;
let latest = self.latest.unwrap_or(f64::MAX).to_bits() as i64;
earliest.hash(state);
latest.hash(state);
}
}
impl Eq for TimeInterval {}
impl PartialEq for TimeInterval {
fn eq(&self, other: &Self) -> bool {
self.earliest == other.earliest && self.latest == other.latest
}
}