Struct minus::Pager

pub struct Pager { /* fields omitted */ }

A struct containing basic configurations for the pager. This is used by all initializing functions

Example

You can use any async runtime, but we are taking the example of [tokio]

 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     use minus::{Pager, LineNumbers, tokio_updating};
     let mut pager = Pager::new().unwrap();
     pager.set_line_numbers(LineNumbers::AlwaysOn);
     pager.set_prompt("A complex configuration");

     // Normally, you would use `futures::join` to join the pager and the text
     // updating function. We are doing this here to make the example simple
     tokio_updating(pager.finish()).await?;
     Ok(())
 }

For static output

 fn main() -> Result<(), Box<dyn std::error::Error>> {
      let mut pager = minus::Pager::new().unwrap();
      pager.set_text("Hello");
      pager.set_prompt("Example");
      minus::page_all(pager)?;
      Ok(())
 }

Implementations

impl Pager

pub fn new() -> Result<Self, AlternateScreenPagingError>

Initialize a new pager configuration

Errors

This function will return an error if it cannot determine the terminal size

Example

let pager = minus::Pager::new().unwrap();

pub fn set_text(&mut self, text: impl Into<String>)

Set the output text to this t

Note that unlike Pager::push_str, this replaces the original text. If you want to append text, use the Pager::push_str function

Example

let mut pager = minus::Pager::new().unwrap();
pager.set_text("This is a line");

pub fn set_line_numbers(&mut self, l: LineNumbers)

Set line number to this setting

Example

use minus::{Pager, LineNumbers};

let mut pager = Pager::new().unwrap();
pager.set_line_numbers(LineNumbers::Enabled);

pub fn set_prompt(&mut self, t: impl Into<String>)

Set the prompt displayed at the prompt to t

Example

use minus::Pager;

let mut pager = Pager::new().unwrap();
pager.set_prompt("my awesome program");

pub fn finish(self) -> PagerMutex

Return a PagerMutex from this Pager. This is gated on tokio_lib or async_std_lib feature

Example

use minus::Pager;

let mut pager = Pager::new().unwrap();
pager.set_text("This output is paged");
let _pager_mutex = pager.finish();

pub fn set_exit_strategy(&mut self, strategy: ExitStrategy)

Set the default exit strategy.

This controls how the pager will behave when the user presses q or Ctrl+C. See ExitStrategy for available options

use minus::{Pager, ExitStrategy};

let mut pager = Pager::new().unwrap();
pager.set_exit_strategy(ExitStrategy::ProcessQuit);

pub fn set_run_no_overflow(&mut self, value: bool)

Set whether to display pager if there’s less data than available screen height

By default this is set to false

use minus::Pager;

let mut pager = Pager::new().unwrap();
pager.set_run_no_overflow(true);

pub fn push_str(&mut self, text: impl Into<String>)

Appends text to the pager output

This function will automatically split the lines, if they overflow the number of terminal columns

let mut pager = minus::Pager::new().unwrap();
pager.push_str("This is some text");

pub fn end_data_stream(&mut self)

Tells the running pager that no more data is coming

Note that after this function is called, any call to Pager::set_text() or Pager::push_str() will panic

Example

use minus::Pager;

let mut pager = Pager::new().unwrap();
pager.set_text("Hello from minus!");
pager.end_data_stream();

pub fn set_input_handler(
    &mut self,
    handler: Box<dyn InputHandler + Send + Sync>
)

Set custom input handler function

See example in InputHandler on using this function

pub fn exit(&mut self)

Run the exit callbacks

Example

use minus::Pager;

fn hello() {
    println!("Hello");
}

let mut pager = Pager::new().unwrap();
pager.add_exit_callback(Box::new(hello));
pager.exit()

pub fn add_exit_callback(&mut self, cb: impl FnMut() + Send + Sync + 'static)

Example

use minus::Pager;

fn hello() {
    println!("Hello");
}

let mut pager = Pager::new().unwrap();
pager.add_exit_callback(Box::new(hello));

Trait Implementations

impl Default for Pager

fn default() -> Self

Returns the “default value” for a type.

impl Write for Pager

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

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

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

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

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