Struct nameless::InputByteStream

pub struct InputByteStream { /* private fields */ }

An input stream for binary input.

An InputByteStream implements Read so it supports read, read_to_end, read_to_str, etc. and can be used anywhere a Read-implementing object is needed.

InputByteStream is unbuffered (even when it is stdin), so wrapping it in a std::io::BufReader is recommended for performance and ease of use.

The primary way to construct an InputByteStream is to use it as a type in a kommand argument or clap_derive struct. Command-line arguments will then be automatically converted into input streams. Currently supported syntaxes include:

• Names starting with https: or http:, which are interpreted as URLs to open.
• Names starting with data: are interpreted as data URLs proving the data in their payload.
• Names starting with file: are interpreted as local filesystem URLs providing paths to files to open.
• “-” is interpreted as standard input.
• “(…)” runs a command with a pipe from the child process’ stdout, on platforms whch support it.
• Names which don’t parse as URLs are interpreted as plain local filesystem paths. To force a string to be interpreted as a plain local path, arrange for it to begin with ./ or /.

Implementations

impl InputByteStream

pub fn media_type(&self) -> &MediaType

If the input stream metadata implies a particular media type, also known as MIME type, return it. Many input streams know their type, though some do not. This is strictly based on available metadata, and not on examining any of the contents of the stream, and there’s no guarantee the contents are valid.

pub fn initial_size(&self) -> Option<u64>

Return the initial size of the stream, in bytes. This is strictly based on available metadata, and not on examining any of the contents of the stream, and the stream could end up being shorter or longer if the source is concurrently modified.

pub fn pseudonym(&self) -> Pseudonym

Return a Pseudonym which encapsulates this stream’s name (typically its filesystem path or its URL). This allows it to be written to an OutputByteStream while otherwise remaining entirely opaque.

Trait Implementations

impl Bufferable for InputByteStream

fn abandon(&mut self)

Close the resource and abandon any pending buffered contents or errors.

fn suggested_buffer_size(&self) -> usize

A suggested size, in bytes, for buffering for performance.

impl Debug for InputByteStream

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Read for InputByteStream

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

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize>

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

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

Determines if this Reader has an efficient read_vectored implementation.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize>

Read all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize>

Read all bytes until EOF in this source, appending them to buf.

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

Read the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

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

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

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

Read the exact number of bytes required to fill cursor.

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

where Self: Sized,

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

fn bytes(self) -> Bytes<Self>

where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R>

where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

where Self: Sized,

Creates an adapter which will read at most limit bytes from it.

impl ReadLayered for InputByteStream

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

Like Read::read, but also returns a Status.

fn read_vectored_with_status( &mut self, bufs: &mut [IoSliceMut<'_>] ) -> Result<(usize, Status)>

Like Read::read_vectored, but also returns a Status.

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

Like Read::read_exact, but uses read_with_status to avoid performing an extra read at the end.

fn minimum_buffer_size(&self) -> usize

Some streams require a buffer of at least a certain size.