#[cfg(test)]
#[path = "diagnostic.tests.rs"]
mod tests;
use crate::details::StaticString;
use crate::envelopes::alloc::{ContextEntry, ErrorMetadata};
use crate::envelopes::{Described, ErrorEnvelope, Located};
use crate::{Context, ErrorContext, ErrorKind};
use core::fmt::{Debug, Display, Formatter};
use core::panic::Location;
use std_alloc::string::String;
use std_alloc::sync::Arc;
#[derive(Clone)]
struct BoxedData<K> {
pub kind: K,
pub metadata: ErrorMetadata,
}
#[derive(Clone)]
pub struct Diagnostic<K> {
inner: Arc<BoxedData<K>>,
}
impl<K: ErrorKind> Diagnostic<K> {
#[inline]
pub(crate) fn into_description(self) -> String {
self.into_metadata().description
}
#[inline]
pub(crate) fn into_location(self) -> Option<&'static Location<'static>> {
self.into_metadata().location
}
#[inline]
pub(crate) fn into_metadata(self) -> ErrorMetadata {
Arc::unwrap_or_clone(self.inner).metadata
}
}
impl<K> Diagnostic<K> {
#[inline]
pub(crate) fn error_kind_ref(&self) -> &K {
&self.inner.kind
}
}
crate::envelopes::impl_error_adapter_traits! {
others={
alloc=[Described],
core=[Located],
},
type=Diagnostic,
}
impl<K: Debug> Debug for Diagnostic<K> {
#[track_caller]
#[inline]
fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
let inner = &*self.inner;
cfg_select! {
feature = "backtrace" => f.debug_struct("Diagnostic")
.field("backtrace", &inner.metadata.backtrace)
.field("context", &inner.metadata.context)
.field("description", &inner.metadata.description)
.field("kind", &inner.kind)
.field("location", &inner.metadata.location)
.finish(),
_ => f.debug_struct("Diagnostic")
.field("context", &inner.metadata.context)
.field("description", &inner.metadata.description)
.field("kind", &inner.kind)
.field("location", &inner.metadata.location)
.finish(),
}
}
}
impl<K: ErrorKind> Display for Diagnostic<K> {
#[track_caller]
#[inline]
fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
let inner = &*self.inner;
Display::fmt(&inner.kind, f)?;
inner.metadata.write_metadata(f)
}
}
impl<K: ErrorKind> ErrorEnvelope for Diagnostic<K> {
type Kind = K;
type Envelope<T: ErrorKind> = Diagnostic<T>;
#[track_caller]
#[inline]
fn convert<T>(self) -> Self::Envelope<T>
where
T: ErrorKind + From<Self::Kind>,
{
let inner = Arc::unwrap_or_clone(self.inner);
Diagnostic {
inner: Arc::new(BoxedData {
kind: From::from(inner.kind),
metadata: inner.metadata,
}),
}
}
#[track_caller]
#[inline]
fn error_kind(&self) -> Self::Kind {
self.inner.kind
}
#[track_caller]
#[inline]
fn new(kind: Self::Kind) -> Self {
Self::with_description(kind, String::new())
}
#[track_caller]
#[inline]
fn with_description<S>(kind: Self::Kind, description: S) -> Self
where
S: StaticString,
{
Self {
inner: Arc::new(BoxedData {
kind,
metadata: ErrorMetadata::new(description, Some(Location::caller())),
}),
}
}
}
impl<K: ErrorKind> ErrorContext for Diagnostic<K> {
#[track_caller]
#[inline]
fn with_context<C, F>(mut self, context: F) -> Self
where
C: Context,
F: FnOnce() -> C,
{
Arc::make_mut(&mut self.inner)
.metadata
.context
.push(ContextEntry {
data: Arc::new(context()),
location: Location::caller(),
});
self
}
}
impl<K: ErrorKind> From<K> for Diagnostic<K> {
#[inline]
fn from(orig: K) -> Self {
Self {
inner: Arc::new(BoxedData {
kind: orig,
metadata: ErrorMetadata::new("", None),
}),
}
}
}
impl<K: ErrorKind> From<Described<K>> for Diagnostic<K> {
#[track_caller]
#[inline]
fn from(orig: Described<K>) -> Self {
Self {
inner: Arc::new(BoxedData {
kind: orig.error_kind(),
metadata: ErrorMetadata::new(orig.into_description(), None),
}),
}
}
}
impl<K: ErrorKind> From<Located<K>> for Diagnostic<K> {
#[track_caller]
#[inline]
fn from(orig: Located<K>) -> Self {
Self {
inner: Arc::new(BoxedData {
kind: orig.error_kind(),
metadata: ErrorMetadata::new("", orig.into_location()),
}),
}
}
}