use std::fmt;
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Change<T> {
pub before: T,
pub after: T,
}
impl<T> Change<T> {
pub fn between(before: T, after: T) -> Option<Self>
where
T: PartialEq,
{
(before != after).then_some(Self { before, after })
}
pub fn new(before: T, after: T) -> Self {
Self { before, after }
}
pub fn map<U>(self, mut f: impl FnMut(T) -> U) -> Change<U> {
Change {
before: f(self.before),
after: f(self.after),
}
}
}
impl<T> Change<Option<T>> {
pub fn is_gain(&self) -> bool {
self.before.is_none() && self.after.is_some()
}
pub fn is_loss(&self) -> bool {
self.before.is_some() && self.after.is_none()
}
pub fn is_replacement(&self) -> bool {
self.before.is_some() && self.after.is_some()
}
}
impl<T: fmt::Display> fmt::Display for Change<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{} -> {}", self.before, self.after)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Presence {
Both,
Added {
before: Coverage,
},
Removed {
after: Coverage,
},
}
impl Presence {
pub fn is_in_both(&self) -> bool {
matches!(self, Presence::Both)
}
pub fn is_added(&self) -> bool {
matches!(self, Presence::Added { .. })
}
pub fn is_removed(&self) -> bool {
matches!(self, Presence::Removed { .. })
}
pub fn counterpart_coverage(&self) -> Option<Coverage> {
match self {
Presence::Both => None,
Presence::Added { before } => Some(*before),
Presence::Removed { after } => Some(*after),
}
}
pub fn is_confirmed(&self) -> bool {
self.counterpart_coverage()
.is_none_or(|coverage| coverage == Coverage::Covered)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Coverage {
Covered,
Withheld,
OutOfScope,
Unstated,
}
impl Coverage {
pub fn is_covered(&self) -> bool {
matches!(self, Coverage::Covered)
}
pub fn is_excluded(&self) -> bool {
matches!(self, Coverage::Withheld | Coverage::OutOfScope)
}
}
impl fmt::Display for Coverage {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Coverage::Covered => write!(f, "covered"),
Coverage::Withheld => write!(f, "withheld"),
Coverage::OutOfScope => write!(f, "out of scope"),
Coverage::Unstated => write!(f, "unstated"),
}
}
}