Struct textwrap::Wrapper

pub struct Wrapper<'a> {
    pub width: usize,
    pub initial_indent: &'a str,
    pub subsequent_indent: &'a str,
    pub break_words: bool,
    pub splitter: Box<WordSplitter>,
}

A Wrapper holds settings for wrapping and filling text. Use it when the convenience wrap and fill functions are not flexible enough.

The algorithm used by the wrap method works by doing a single scan over words in the input string and splitting them into one or more lines. The time and memory complexity is O(n) where n is the length of the input string.

Fields

width: usize

The width in columns at which the text will be wrapped.

initial_indent: &'a str

Indentation used for the first line of output.

subsequent_indent: &'a str

Indentation used for subsequent lines of output.

break_words: bool

Allow long words to be broken if they cannot fit on a line. When set to false, some lines be being longer than self.width.

splitter: Box<WordSplitter>

The method for splitting words. If the hyphenation feature is enabled, you can use a hyphenation::language::Corpus here to get language-aware hyphenation.

Methods

impl<'a> Wrapper<'a>

fn new(width: usize) -> Wrapper<'a>

Create a new Wrapper for wrapping at the specified width. By default, we allow words longer than width to be broken. A HyphenSplitter will be used by default for splitting words. See the WordSplitter trait for other options.

fn with_termwidth() -> Wrapper<'a>

Crate a new Wrapper for wrapping text at the current terminal width. If the terminal width cannot be determined (typically because the standard input and output is not connected to a terminal), a width of 80 characters will be used. Other settings use the same defaults as Wrapper::new.

fn fill(&self, s: &str) -> String

Fill a line of text at self.width characters. Strings are wrapped based on their displayed width, not their size in bytes.

The result is a string with newlines between each line. Use the wrap method if you need access to the individual lines.

use textwrap::Wrapper;

let wrapper = Wrapper::new(15);
assert_eq!(wrapper.fill("Memory safety without garbage collection."),
           "Memory safety\nwithout garbage\ncollection.");

This method simply joins the lines produced by wrap. As such, it inherits the O(n) time and memory complexity where n is the input string length.

fn wrap(&self, s: &str) -> Vec<String>

Wrap a line of text at self.width characters. Strings are wrapped based on their displayed width, not their size in bytes.

use textwrap::Wrapper;

let wrap15 = Wrapper::new(15);
assert_eq!(wrap15.wrap("Concurrency without data races."),
           vec!["Concurrency",
                "without data",
                "races."]);

let wrap20 = Wrapper::new(20);
assert_eq!(wrap20.wrap("Concurrency without data races."),
           vec!["Concurrency without",
                "data races."]);

The WordSplitter stored in self.splitter is used whenever when a word is too large to fit on the current line. By changing the field, different hyphenation strategies can be implemented.

This method does a single scan over the input string, it has an O(n) time and memory complexity where n is the input string length.