Trait ContextualDisplay

pub trait ContextualDisplay<Context> {
    type Error;

    // Required method
    fn contextual_format<F: Write>(
        &self,
        f: &mut F,
        context: &Context,
    ) -> Result<(), Self::Error>;

    // Provided methods
    fn format<F: Write, TContext: Into<Context>>(
        &self,
        f: &mut F,
        context: TContext,
    ) -> Result<(), Self::Error> { ... }
    fn display<'a, 'b, TContext: Into<Context>>(
        &'a self,
        context: TContext,
    ) -> ContextDisplayable<'a, Self, Context> { ... }
    fn to_string<'a, 'b, TContext: Into<Context>>(
        &'a self,
        context: TContext,
    ) -> String { ... }
}

This trait is used where context is required to correctly display a value.

Typically, this is due to needing to know the current network to display addresses. Other forms of Context are also possible. See ComponentAddress or TransactionReceipt in the radix-engine crate for example implementations.

The Context used should typically just be a wrapper type around references, and so be a small, cheap, ephemeral value on the stack (if it’s not just optimized away entirely). It is therefore recommended that the Context implement Copy, to make it very easy to pass around and re-use.

Required Associated Types

type Error

Required Methods

fn contextual_format<F: Write>( &self, f: &mut F, context: &Context, ) -> Result<(), Self::Error>

Formats the value to the given fmt::Write buffer, making use of the provided context. See also format, which is typically easier to use, as it takes an Into<Context> instead of a &Context.

Provided Methods

fn format<F: Write, TContext: Into<Context>>( &self, f: &mut F, context: TContext, ) -> Result<(), Self::Error>

Formats the value to the given fmt::Write buffer, making use of the provided context. See also contextual_format, which takes a &Context instead of an Into<Context>.

Alternatively, the display method can be used to create an object that can be used directly in a format! style macro.

fn display<'a, 'b, TContext: Into<Context>>( &'a self, context: TContext, ) -> ContextDisplayable<'a, Self, Context>

Returns an object implementing fmt::Display, which can be used in a format! style macro.

Whilst this is syntactically nicer, beware that the use of format! absorbs any errors during formatting, replacing them with fmt::Error. If you’d like to preserve errors, use the format method instead. This may require manually splitting up your format! style macro. For example:

// Syntactically nice, but the AddressError is swallowed into fmt::Error
write!(f, "ComponentAddress(\"{}\")", address.display(context))?;

// Less nice, but the AddressError is correctly returned
f.write_str("ComponentAddress(\"")?;
address.format(f, context)?;
f.write_str("\")")?;

fn to_string<'a, 'b, TContext: Into<Context>>( &'a self, context: TContext, ) -> String

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.

Implementors