Struct fast_input::FastInput

pub struct FastInput { /* fields omitted */ }

Simplifies reading and parsing of known input in a speedy fashion.

Reads all data on standard in into a byte buffer. Provides methods to simplify reading and parsing of lines, specifically aimed to aid in competetive programming where the input is known and correct. Most functions panic if the input is not correct and on the specified format. Note: FastInput assumes *nix line-endings (\n).

FastInput uses interior mutability to allow for zero-copy reading and referencing of string input.

Examples

Creating a new FastInput and reading two lines:

// Input:
// Hello!
// 12 2000
use fast_input::FastInput;

let input = FastInput::new();
// Must make into String as next_line returns a slice to the internal buffer
// and the second input line advances the internal buffer.
let first_line = input.next_line().to_owned();
let (a, b): (u32, u32) = input.next_tuple();

println!("First line was: {}, a + b = {}", first_line, a + b);

Mixing &str with parseables:

To facilitate simple, zero-copy reading of string slices, FastInput defines the Str type. The following example reads (name, age) (&str, u8) pairs and stores them in a HashMap.

use fast_input::{FastInput, Str};
use std::collections::HashMap;

// Input:
// Sven 12
// Lorna 22
let input = FastInput::new();
let mut map = HashMap::new();
let (sven, sven_age) = input.next_tuple::<Str, u8>();
let (lorna, lorna_age) = input.next_tuple::<Str, u8>();

// Deref the Str to a &str
map.insert(*sven, sven_age);
map.insert(*lorna, lorna_age);
assert_eq!(map["Sven"], 12);

Implementations

impl FastInput

pub fn new() -> Self

Creates a new FastInput.

Upon creation the entire contents of standard input will be read. The function will block until EOF is reached. If you are using a terminal you can send EOF using CTRL + D. The initial buffer size is 8196 bytes.

pub fn with_buffer_size(buffer_size: usize) -> Self

Creates a new FastInput with a specified buffer size.

For more information, see [new].

pub fn with_reader<T: Read>(input: T) -> Self

Creates a new FastInput with a given input that implements Read

Examples

Creating a FastInput over a byte slice:

use fast_input::FastInput;
use std::io::Read;
 
let data = "1 2\n3 4".as_bytes();

let input = FastInput::with_reader(data);

let (one, two) = input.next_tuple::<u32, u32>();
let (three, four) = input.next_tuple::<u32, u32>();

assert_eq!((1, 2), (one, two));
assert_eq!((3, 4), (three, four));
assert_eq!(false, input.has_next_line());

For more information, see [new].

pub fn next_line<'a>(&'a self) -> &'a str

Reads the next line and returns it.

Panics

The function panics if there is no more data in the buffer. If you are unsure if there is a next line, see [has_next_line].

pub fn next<'a, T: FastParse<'a>>(&'a self) -> T

Reads a single value and parses it.

Examples

Reading an integer:

//Input:
//123
use fast_input::FastInput;

let input = FastInput::new();
let number: i32 = input.next();
println!("{}", number);

pub fn next_tuple<'a, T1: FastParse<'a>, T2: FastParse<'a>>(
    &'a self
) -> (T1, T2)

Reads two elements separated by a space, and returns them parsed as a tuple.

Examples

Reading an i32 and a f64:

use fast_input::FastInput;

let input = FastInput::new();
let (age, length): (i32, f64) = input.next_tuple();
println!("{} {}", age, length);

Panics

If there is no more data in the buffer. See [has_next_line].

pub fn next_triple<'a, T1: FastParse<'a>, T2: FastParse<'a>, T3: FastParse<'a>>(
    &'a self
) -> (T1, T2, T3)

Reads three elements separated by a space, and returns them as a triple.

Panics

If there is no more data in the buffer. See [has_next_line].

pub fn next_quad<'a, T1: FastParse<'a>, T2: FastParse<'a>, T3: FastParse<'a>, T4: FastParse<'a>>(
    &'a self
) -> (T1, T2, T3, T4)

Reads four elements separated by a space, and returns them as a quad-tuple.

Panics

If there is no more data in the buffer. See [has_next_line].

pub fn next_quintuple<'a, T1: FastParse<'a>, T2: FastParse<'a>, T3: FastParse<'a>, T4: FastParse<'a>, T5: FastParse<'a>>(
    &'a self
) -> (T1, T2, T3, T4, T5)

Reads five elements separated by a space, and returns them as a quintuple.

Panics

If there is no more data in the buffer. See [has_next_line].

pub fn next_as_iter<'a, T: FastParse<'a>>(
    &'a self
) -> impl Iterator<Item = T> + '_

Reads the next line and returns an iterator over the elements of the line.

Examples

Collecting a line into a Vec of integers.

use fast_input::FastInput;

let input = FastInput::new();
let numbers: Vec<u32> = input.next_as_iter().collect();
println!("Last line contained {} numbers!", numbers.len());

Panics

If there is no more data in the buffer. See [has_next_line].

pub fn next_split<'a>(&'a self) -> impl Iterator<Item = &'a str> + '_

Reads the next line and returns an iterator over the elements (no parsing).

Examples

Reading a sentence and printing the individual words:

use fast_input::FastInput;

let input = FastInput::new();
let words = input.next_split();
for (i, word) in words.enumerate() {
    println!("Word {} was: {}", i, word);
}

Panics

If there is no more data in the buffer. See [has_next_line].

pub fn has_next_line(&self) -> bool

Checks if there is more data available in the buffer.

Examples

Reading until EOF:

use fast_input::FastInput;

let input = FastInput::new();
while input.has_next_line() {
    println!("{}", input.next_line());
}

pub fn next_str_tuple(&self) -> (&str, &str)

👎 Deprecated since 0.1.1:

Use next_tuple with the Str type instead.

Returns the next line as a str tuple.

Panics

If there is no more data in the buffer. See [has_next_line].

pub fn next_str_triple(&self) -> (&str, &str, &str)

👎 Deprecated since 0.1.1:

Use next_triple with the Str type instead.

Returns the next line as a str triple.

Panics

If there is no more data in the buffer. See [has_next_line].