#![forbid(unsafe_code)]
#![warn(missing_docs)]
use std::collections::BTreeMap;
use std::error::Error;
use std::fmt;
pub const MLIT_CROSSING_SAFETY_URL: &str = "https://www.mlit.go.jp/tetudo/tetudo_tk9_000004.html";
pub const MLIT_TRANSPORT_HUB_URL: &str = "https://www.mlit.go.jp/road/busterminal/";
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum TransportPrinciple {
InterfaceSafety,
ConnectedJourney,
UniversalAccess,
ReliableFlow,
EnvironmentalCare,
NetworkResilience,
}
impl TransportPrinciple {
pub const ALL: [Self; 6] = [
Self::InterfaceSafety,
Self::ConnectedJourney,
Self::UniversalAccess,
Self::ReliableFlow,
Self::EnvironmentalCare,
Self::NetworkResilience,
];
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Impact {
Improves,
Neutral,
NeedsMitigation,
Harms,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Assessment {
impact: Impact,
evidence: String,
}
impl Assessment {
pub fn new(impact: Impact, evidence: impl Into<String>) -> Result<Self, TransportError> {
let evidence = evidence.into();
if evidence.trim().is_empty() {
return Err(TransportError::EmptyEvidence);
}
Ok(Self { impact, evidence })
}
pub const fn impact(&self) -> Impact {
self.impact
}
pub fn evidence(&self) -> &str {
&self.evidence
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TransportPlan {
name: String,
assessments: BTreeMap<TransportPrinciple, Assessment>,
}
impl TransportPlan {
pub fn new(name: impl Into<String>) -> Result<Self, TransportError> {
let name = name.into();
if name.trim().is_empty() {
return Err(TransportError::EmptyPlanName);
}
Ok(Self {
name,
assessments: BTreeMap::new(),
})
}
pub fn assess(
mut self,
principle: TransportPrinciple,
impact: Impact,
evidence: impl Into<String>,
) -> Result<Self, TransportError> {
self.set_assessment(principle, impact, evidence)?;
Ok(self)
}
pub fn set_assessment(
&mut self,
principle: TransportPrinciple,
impact: Impact,
evidence: impl Into<String>,
) -> Result<(), TransportError> {
self.assessments
.insert(principle, Assessment::new(impact, evidence)?);
Ok(())
}
pub fn name(&self) -> &str {
&self.name
}
pub fn assessment(&self, principle: TransportPrinciple) -> Option<&Assessment> {
self.assessments.get(&principle)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TransportDecision {
Decline,
NeedsEvidence,
Revise,
Integrated,
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct IntegratedPolicy;
impl IntegratedPolicy {
pub fn evaluate(plan: &TransportPlan) -> TransportReport {
let mut missing = Vec::new();
let mut needs_mitigation = Vec::new();
let mut harms = Vec::new();
for principle in TransportPrinciple::ALL {
match plan.assessment(principle).map(Assessment::impact) {
None => missing.push(principle),
Some(Impact::Improves | Impact::Neutral) => {}
Some(Impact::NeedsMitigation) => needs_mitigation.push(principle),
Some(Impact::Harms) => harms.push(principle),
}
}
let safety_harm = harms.contains(&TransportPrinciple::InterfaceSafety);
let decision = if safety_harm {
TransportDecision::Decline
} else if !missing.is_empty() {
TransportDecision::NeedsEvidence
} else if !needs_mitigation.is_empty() || !harms.is_empty() {
TransportDecision::Revise
} else {
TransportDecision::Integrated
};
TransportReport {
decision,
missing,
needs_mitigation,
harms,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TransportReport {
decision: TransportDecision,
missing: Vec<TransportPrinciple>,
needs_mitigation: Vec<TransportPrinciple>,
harms: Vec<TransportPrinciple>,
}
impl TransportReport {
pub const fn decision(&self) -> TransportDecision {
self.decision
}
pub fn missing(&self) -> &[TransportPrinciple] {
&self.missing
}
pub fn needs_mitigation(&self) -> &[TransportPrinciple] {
&self.needs_mitigation
}
pub fn harms(&self) -> &[TransportPrinciple] {
&self.harms
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TransportError {
EmptyPlanName,
EmptyEvidence,
}
impl fmt::Display for TransportError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::EmptyPlanName => formatter.write_str("plan name must not be blank"),
Self::EmptyEvidence => formatter.write_str("assessment evidence must not be blank"),
}
}
}
impl Error for TransportError {}
#[cfg(test)]
mod tests {
use super::*;
fn integrated_plan() -> TransportPlan {
TransportPrinciple::ALL
.into_iter()
.try_fold(
TransportPlan::new("station approach").unwrap(),
|plan, principle| plan.assess(principle, Impact::Improves, "measured improvement"),
)
.unwrap()
}
#[test]
fn complete_positive_plan_is_integrated() {
assert_eq!(
IntegratedPolicy::evaluate(&integrated_plan()).decision(),
TransportDecision::Integrated
);
}
#[test]
fn safety_harm_is_a_veto_even_with_missing_evidence() {
let plan = TransportPlan::new("crossing change")
.unwrap()
.assess(
TransportPrinciple::InterfaceSafety,
Impact::Harms,
"pedestrian conflict increases",
)
.unwrap();
let report = IntegratedPolicy::evaluate(&plan);
assert_eq!(report.decision(), TransportDecision::Decline);
assert_eq!(report.harms(), &[TransportPrinciple::InterfaceSafety]);
}
#[test]
fn empty_plan_needs_all_evidence_in_stable_order() {
let report = IntegratedPolicy::evaluate(&TransportPlan::new("draft").unwrap());
assert_eq!(report.decision(), TransportDecision::NeedsEvidence);
assert_eq!(report.missing(), &TransportPrinciple::ALL);
}
#[test]
fn unresolved_access_risk_requires_revision() {
let mut plan = integrated_plan();
plan.set_assessment(
TransportPrinciple::UniversalAccess,
Impact::NeedsMitigation,
"step-free detour is too long",
)
.unwrap();
let report = IntegratedPolicy::evaluate(&plan);
assert_eq!(report.decision(), TransportDecision::Revise);
assert_eq!(
report.needs_mitigation(),
&[TransportPrinciple::UniversalAccess]
);
}
#[test]
fn blank_inputs_are_rejected() {
assert_eq!(TransportPlan::new(" "), Err(TransportError::EmptyPlanName));
assert_eq!(
Assessment::new(Impact::Neutral, "\t"),
Err(TransportError::EmptyEvidence)
);
}
}