use std::error::Error;
use std::fmt::Debug;
use std::fmt::Display;
use std::fmt::Formatter;
use std::fmt::Result as FmtResult;
use std::sync::Mutex;
#[must_use]
pub struct ContractSource {
error: Mutex<Option<Box<dyn Error + Send>>>,
}
impl ContractSource {
pub(crate) fn new(error: impl Error + Send + 'static) -> Self {
Self {
error: Mutex::new(Some(Box::new(error))),
}
}
pub fn inspect<T>(&self, inspect: impl FnOnce(&(dyn Error + Send + 'static)) -> T) -> Option<T> {
let guard = self.error.lock().unwrap_or_else(|poison| poison.into_inner());
guard.as_deref().map(inspect)
}
pub fn take(&self) -> Option<Box<dyn Error + Send>> {
self.error.lock().unwrap_or_else(|poison| poison.into_inner()).take()
}
}
impl Debug for ContractSource {
fn fmt(&self, formatter: &mut Formatter<'_>) -> FmtResult {
formatter.write_str("ContractSource { original_error: retained }")
}
}
impl Display for ContractSource {
fn fmt(&self, formatter: &mut Formatter<'_>) -> FmtResult {
formatter.write_str("original provider failure; inspect the retained source for recovery")
}
}
impl Error for ContractSource {}
#[cfg(test)]
mod tests {
use std::panic::AssertUnwindSafe;
use super::ContractSource;
#[test]
fn test_poisoned_source_lock_remains_inspectable_and_transferable() {
let source = ContractSource::new(std::io::Error::other("poisoned source"));
let _ = std::panic::catch_unwind(AssertUnwindSafe(|| {
let _guard = source.error.lock().unwrap();
panic!("poison source lock");
}));
assert_eq!(
source.inspect(|error| error.to_string()),
Some("poisoned source".to_owned())
);
assert_eq!(source.inspect(|error| error.is::<std::io::Error>()), Some(true));
assert_eq!(source.take().unwrap().to_string(), "poisoned source");
assert!(source.take().is_none());
}
}