Trait NodeContextExt 

pub trait NodeContextExt<T, Context>: Sized {
    type Error: Into<Box<dyn Error>>;

    // Required method
    fn with_node_context<Function, NewError>(
        self,
        ctx: &Context,
        f: Function,
    ) -> Result<T, NodeError>
       where Function: FnOnce(Self::Error) -> NewError,
             NewError: Into<Box<dyn Error>>;

    // Provided methods
    fn node_context(self, ctx: &Context) -> Result<T, NodeError> { ... }
    fn node_context_message(
        self,
        ctx: &Context,
        message: &str,
    ) -> Result<T, NodeError> { ... }
}

Required Associated Types

type Error: Into<Box<dyn Error>>

Required Methods

fn with_node_context<Function, NewError>( self, ctx: &Context, f: Function, ) -> Result<T, NodeError>

where Function: FnOnce(Self::Error) -> NewError, NewError: Into<Box<dyn Error>>,

Provided Methods

fn node_context(self, ctx: &Context) -> Result<T, NodeError>

fn node_context_message( self, ctx: &Context, message: &str, ) -> Result<T, NodeError>

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<T> NodeContextExt<T, NodeContextBase> for Option<T>

type Error = &'static str

fn with_node_context<Function, NewError>( self, ctx: &NodeContextBase, f: Function, ) -> Result<T, NodeError>

where Function: FnOnce(Self::Error) -> NewError, NewError: Into<Box<dyn Error>>,

fn node_context_message( self, ctx: &NodeContextBase, message: &str, ) -> Result<T, NodeError>

impl<T, E> NodeContextExt<T, NodeContextBase> for Result<T, E>

where E: Into<Box<dyn Error>>,

type Error = E

fn with_node_context<Function, NewError>( self, ctx: &NodeContextBase, f: Function, ) -> Result<T, NodeError>

where Function: FnOnce(Self::Error) -> NewError, NewError: Into<Box<dyn Error>>,

impl<T, E, NodeData, TraceData> NodeContextExt<T, NodeContext<NodeData, TraceData>> for Result<T, E>

where E: Into<Box<dyn Error>>, NodeData: NodeDataType, TraceData: TraceDataType,

type Error = E

fn with_node_context<Function, NewError>( self, ctx: &NodeContext<NodeData, TraceData>, f: Function, ) -> Result<T, NodeError>

where Function: FnOnce(Self::Error) -> NewError, NewError: Into<Box<dyn Error>>,

impl<T, NodeData, TraceData> NodeContextExt<T, NodeContext<NodeData, TraceData>> for Option<T>

where NodeData: NodeDataType, TraceData: TraceDataType,

type Error = &'static str

fn with_node_context<Function, NewError>( self, ctx: &NodeContext<NodeData, TraceData>, f: Function, ) -> Result<T, NodeError>

where Function: FnOnce(Self::Error) -> NewError, NewError: Into<Box<dyn Error>>,

fn node_context_message( self, ctx: &NodeContext<NodeData, TraceData>, message: &str, ) -> Result<T, NodeError>

Implementors