use std::borrow::Cow;use std::fmt::{Display, Formatter}; use crate::Message; /// The kind of resource exhaustion which prevented an operation from completing.#[derive(Clone, Copy, Debug, Eq, PartialEq)]#[non_exhaustive]pub enum ResourceExhaustionKind {    /// An application-configured allocation limit was exceeded.    AllocationLimit,    /// An allocation size could not be represented or memory could not be reserved.    AllocationFailure,} /// An error caused by exhausting a finite resource.#[derive(Debug)]pub struct ResourceExhaustionError {    /// The kind of resource exhaustion.    pub kind: ResourceExhaustionKind,    /// The error message.    pub message: Cow<'static, str>,} impl ResourceExhaustionError {    /// Create a new instance with `kind` that displays the given `message`.    pub fn new(kind: ResourceExhaustionKind, message: impl Into<Cow<'static, str>>) -> Self {        ResourceExhaustionError {            kind,            message: message.into(),        }    }     /// Return the kind of resource exhaustion.    pub fn kind(&self) -> ResourceExhaustionKind {        self.kind    }} impl Display for ResourceExhaustionError {    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {        f.write_str(self.message.as_ref())    }} impl std::error::Error for ResourceExhaustionError {} /// An error caused by malformed or internally inconsistent data.#[derive(Debug)]pub struct CorruptionError {    /// The error message.    pub message: Cow<'static, str>,} impl CorruptionError {    /// Create a new instance that displays the given `message`.    pub fn new(message: impl Into<Cow<'static, str>>) -> Self {        CorruptionError {            message: message.into(),        }    }} impl Display for CorruptionError {    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {        f.write_str(self.message.as_ref())    }} impl std::error::Error for CorruptionError {} impl From<Message> for CorruptionError {    fn from(Message(msg): Message) -> Self {        CorruptionError::new(msg)    }} impl From<String> for CorruptionError {    fn from(msg: String) -> Self {        CorruptionError::new(msg)    }} impl From<&'static str> for CorruptionError {    fn from(msg: &'static str) -> Self {        CorruptionError::new(msg)    }} /// An error indicating that a requested resource does not exist.#[derive(Debug)]pub struct NotFoundError {    /// The error message.    pub message: Cow<'static, str>,} impl NotFoundError {    /// Create a new instance that displays the given `message`.    pub fn new(message: impl Into<Cow<'static, str>>) -> Self {        NotFoundError {            message: message.into(),        }    }} impl Display for NotFoundError {    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {        f.write_str(self.message.as_ref())    }} impl std::error::Error for NotFoundError {} impl From<Message> for NotFoundError {    fn from(Message(msg): Message) -> Self {        NotFoundError::new(msg)    }} impl From<String> for NotFoundError {    fn from(msg: String) -> Self {        NotFoundError::new(msg)    }} impl From<&'static str> for NotFoundError {    fn from(msg: &'static str) -> Self {        NotFoundError::new(msg)    }} /// A transparent wrapper for dependency-specific errors known to be retryable.#[derive(Debug)]pub struct RetryableError(Box<dyn std::error::Error + Send + Sync + 'static>); impl RetryableError {    /// Mark `source` as retryable.    pub fn new(source: impl std::error::Error + Send + Sync + 'static) -> Self {        RetryableError(Box::new(source))    }} impl Display for RetryableError {    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {        Display::fmt(&self.0, f)    }} impl std::error::Error for RetryableError {    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {        Some(self.0.as_ref())    }}