Struct FastInput

pub struct FastInput { /* private fields */ }

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, FastParse};

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();

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, FastParse, Str};
use std::collections::HashMap;

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

// 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.

Examples found in repository

examples/read_into_map.rs (line 6)

fn main() {
    println!("Enter String number tuples (hello 2)");
    let inp = FastInput::new();
    let mut people = HashMap::new();
    while inp.has_next_line() {
        let (name, age): (Str, u16) = inp.next();
        *people.entry(*name).or_default() = age;
    }
    println!("{:?}", people);
}

examples/read_some_lines.rs (line 12)

fn solve<'a>() {
    print!("Enter some text, end with EOF (Ctrl + D): ");
    std::io::stdout().flush().expect("Failed to flush stdout..");

    let inp = FastInput::new();
    let line = inp.next_line();
    println!("The first line was: {}", line);
    
    let rest: Vec<_> = inp.lines().collect();
    println!("There where {} more lines after the first one", rest.len());
}

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, FastParse};
use std::io::Read;

let data = "1 2\n3 4".as_bytes();

let input = FastInput::with_reader(data);

let (one, two) = input.next();
let (three, four) = input.next();

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(&self) -> &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].

Examples found in repository

examples/read_some_lines.rs (line 13)

fn solve<'a>() {
    print!("Enter some text, end with EOF (Ctrl + D): ");
    std::io::stdout().flush().expect("Failed to flush stdout..");

    let inp = FastInput::new();
    let line = inp.next_line();
    println!("The first line was: {}", line);
    
    let rest: Vec<_> = inp.lines().collect();
    println!("There where {} more lines after the first one", rest.len());
}

pub fn next_parsed<'a, T: FParse<'a>>(&'a self) -> T

Reads the next line as 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_parsed();
println!("{}", number);

pub fn next_as_iter<'a, T: FParse<'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());
}

Examples found in repository

examples/read_into_map.rs (line 8)

fn main() {
    println!("Enter String number tuples (hello 2)");
    let inp = FastInput::new();
    let mut people = HashMap::new();
    while inp.has_next_line() {
        let (name, age): (Str, u16) = inp.next();
        *people.entry(*name).or_default() = age;
    }
    println!("{:?}", people);
}

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

Returns a (consuming) iterator over all remaining lines.

Examples

Printing all lines:

use fast_input::FastInput;

let data = "First\nSecond\nThird".as_bytes();
let input = FastInput::with_reader(data);
let all_lines: Vec<_> = input.lines().collect();

assert_eq!(&all_lines, &["First", "Second", "Third"]);
assert_eq!(input.has_next_line(), false);

Examples found in repository

examples/read_some_lines.rs (line 16)

fn solve<'a>() {
    print!("Enter some text, end with EOF (Ctrl + D): ");
    std::io::stdout().flush().expect("Failed to flush stdout..");

    let inp = FastInput::new();
    let line = inp.next_line();
    println!("The first line was: {}", line);
    
    let rest: Vec<_> = inp.lines().collect();
    println!("There where {} more lines after the first one", rest.len());
}

Trait Implementations

impl Default for FastInput

fn default() -> Self

Returns the “default value” for a type.

impl<'a, T1, T2> FastParse<'a, (T1, T2)> for FastInput

where T1: FParse<'a>, T2: FParse<'a>,

fn next(&'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, FastParse};

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

Panics

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

impl<'a, T1, T2, T3> FastParse<'a, (T1, T2, T3)> for FastInput

where T1: FParse<'a>, T2: FParse<'a>, T3: FParse<'a>,

fn next(&'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].

impl<'a, T1, T2, T3, T4> FastParse<'a, (T1, T2, T3, T4)> for FastInput

where T1: FParse<'a>, T2: FParse<'a>, T3: FParse<'a>, T4: FParse<'a>,

fn next(&'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].

impl<'a, T1, T2, T3, T4, T5> FastParse<'a, (T1, T2, T3, T4, T5)> for FastInput

where T1: FParse<'a>, T2: FParse<'a>, T3: FParse<'a>, T4: FParse<'a>, T5: FParse<'a>,

fn next(&'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].