Struct conciliator::spin::Line

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

Wrap a Buffer to print it and a newline when dropped, (Spinner version)

This struct “borrows” (figuratively) a Buffer from a Spinner. It holds a reference to this Spinner, and the destructor uses this reference to print the buffer to the terminal.

Before the buffer is printed, a newline character is appended to it. This can be avoided by using Line::no_newline to turn it into a NoNewLine.

Implementations

impl<'s> Line<'s>

pub fn print(self)

Print this Line into the Spinner. This is equivalent to dropping.

pub fn discard(self)

Discard and drop this buffer without printing it

pub fn no_newline(self) -> NoNewLine<'s>

No longer add the newline when dropped

Make sure to end every chunk of output with a newline, otherwise the last line will get overwritten by the Spinner message!
Additionally, be careful with using this and sending a newline in another Buffer afterwards: if you get unlucky, the Spinner thread might print and overwrite the contents of this one before it gets to the one that contains the newline. Just how unlucky you would have to be is hard to say, and it probably depends on the refresh-rate of the animation you use, but in my estimation it is extremely unlikely.

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 Line<'s>

type Target = Buffer

The resulting type after dereferencing.

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

Dereferences the value.

impl<'s> DerefMut for Line<'s>

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

Mutably dereferences the value.

impl<'s> Drop for Line<'s>

fn drop(&mut self)

The Line prints itself to the Spinner when dropped

impl<'s> EmitEscapes for Line<'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 Line<'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.