Enum PagedOutput 

pub enum PagedOutput {
    Terminal {
        stdout: Stdout,
    },
    ExternalPager {
        child: Child,
        child_stdin: Option<ChildStdin>,
    },
    BuiltinPager {
        out_writer: Option<PipeWriter>,
        pager_thread: Option<JoinHandle<Result<()>>>,
    },
}

Output wrapper that optionally pages output through a pager.

When a pager is active, output is piped to the pager process (external) or thread (builtin). When finalized, the pipe is closed and we wait for the pager to exit.

Implements Drop to ensure cleanup happens even if finalize is not called explicitly. During a panic, pipes are closed but we skip waiting for the pager to avoid potential double-panic.

Variants

Terminal

Direct output to terminal (no paging).

Fields

stdout: Stdout

Standard output handle.

ExternalPager

Output through an external pager process.

Fields

child: Child

The pager child process.

child_stdin: Option<ChildStdin>

Stdin pipe to the pager (for writing output).

This is an Option to allow taking ownership in Drop and finalize.

BuiltinPager

Output through the builtin streampager.

Fields

out_writer: Option<PipeWriter>

Pipe writer for stdout (for writing output).

This is an Option to allow taking ownership in Drop and finalize.

pager_thread: Option<JoinHandle<Result<()>>>

The pager thread handle.

This is an Option to allow taking ownership in finalize.

Implementations

impl PagedOutput

pub fn terminal() -> Self

Creates a new terminal output (no paging).

pub fn request_pager( pager: &PagerSetting, paginate: PaginateSetting, streampager_config: &StreampagerConfig, ) -> Self

Attempts to spawn a pager if conditions are met.

Returns Terminal output if:

• paginate is Never
• stdout is not a TTY
• the pager command fails to spawn

On pager spawn failure, a warning is logged and terminal output is returned.

pub fn is_interactive(&self) -> bool

Returns true if output will be displayed interactively.

This is used to determine whether to use human-readable formatting (interactive) or machine-friendly oneline formatting (piped).

• For terminal output: returns whether stdout is a TTY.
• For paged output: always returns true, since the pager displays output interactively to the user.

pub fn finalize(self)

Finalizes the pager output.

For terminal output, this is a no-op. For paged output, this closes the pipe and waits for the pager process/thread to exit. Errors during wait are logged but not propagated.

This method is also called by Drop, so explicit calls are optional but recommended for clarity.

Trait Implementations

impl Drop for PagedOutput

fn drop(&mut self)

Executes the destructor for this type.

impl WriteStr for PagedOutput

fn write_str(&mut self, s: &str) -> Result<()>

Writes a string to the writer.

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

Flushes the writer, ensuring that all intermediately buffered contents reach their destination.

fn write_char(&mut self, c: char) -> Result<()>

Writes a single character to the writer.

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

Writes a formatted string to the writer.