Struct conciliator::spin::Message

pub struct Message<'s> { /* private fields */ }

Special Buffer that sets the Spinner message when dropped

Make sure that the Buffer does not contain any newlines and that it is short enough to fit onto a single line. If you don’t, the output will get messed up, and the user might not be able to read all of it (since some parts might get overwritten).

There’s no (easy) way to guarantee this doesn’t happen, the user can resize their terminal however they see fit, at any point. In the future, there may be support for automatically truncating messages that are too long to fit into a single line, but currently there is not (it’s quite a bit more complicated than just checking the length of the Buffer).

So, for the time being, just make sure that, together with the width of the animation (+3 for the brackets), the total stays well under the 80 columns rule.

Implementations

impl<'s> Message<'s>

pub fn set(self)

Set the contents of this buffer as the persistent Spinner status message. This is equivalent to dropping.

pub fn discard(self)

Discard and drop this buffer without changing the Spinner status message

Methods from Deref<Target = Buffer>

pub fn push_inline<T: Inline>(&mut self, thing: &T) -> &mut Self

Append thing onto the buffer using the Inline trait

pub fn push<M, T: Pushable<M>>(&mut self, thing: T) -> &mut Self

Append thing onto the buffer using either Inline or Display, doesn’t work if both are implemented for T

Pushable is blanket-implemented for both Inline and Display types. This would normally not be possible, because both blanket implementations could apply to the same type, thereby causing a conflict (Rust does not have any specialization or way to express where T: NOT Trait). So instead, this uses a trick that relies on a “marker type” being inferred.

This workaround is described in detail on Pushable, but in short:

• Pushable has a type parameter M (i.e. trait Pushable<M>) that is not used except to make distinct implementations possible for the same type
• impl<T: Display> Pushable<marker::AsDisplay> for T
• impl<T: Inline> Pushable<marker::AsInline> for T
• push is implemented for any T: Pushable<M> with any M
• when there is only one applicable implementation, the marker type M can be inferred and won’t need to be specified
• Surprisingly, it just works!

If, however, there are multiple applicable implementations (i.e. for a type implements Inline and Display), the type cannot be inferred: type annotations needed. In this case, it is easier to just use the more specific function instead of bothering with the type annotations. (For the time being, the marker types are private, so type annotations are also impossible.)

 use conciliator::{Conciliator, Wrap};
 let con = conciliator::init();
 con.line(..)
     .push("Test") // &str,
     .push(123)    // i32 and
     .push(' ')    // char all implement Display
     .push(Wrap::Alpha(":^)")); // Wrap implements Inline

Trait Implementations

impl<'s> Deref for Message<'s>

type Target = Buffer

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'s> DerefMut for Message<'s>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'s> Drop for Message<'s>

fn drop(&mut self)

The Message sends itself to the Spinner thread when dropped

impl<'s> EmitEscapes for Message<'s>

fn escapes_recognized(&self) -> bool

If this returns true, escape codes will be emitted.

fn set_color(&mut self, color: ColorCode) -> IoResult<()>

Write a “foreground color” escape code (\x1B[3???m)

fn set_bold(&mut self) -> IoResult<()>

Write a “bold text” escape code (\x1B[1m)

fn reset(&mut self) -> IoResult<()>

Write a “reset style and color” escape code (\x1B[0m)

fn write_with_color<T: Display + ?Sized>(&mut self, color: ColorCode, thing: &T)

set_color, then write! and then reset, provided for convenience

fn write_with_color_bold<T: Display + ?Sized>( &mut self, color: ColorCode, thing: &T )

set_bold & set_color, then write! and then reset, provided for convenience

impl<'s> Write for Message<'s>

fn write(&mut self, buf: &[u8]) -> IoResult<usize>

Write a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> IoResult<()>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Write.