Struct fast_input::FastInput
source · [−]pub struct FastInput { /* private fields */ }
Expand description
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
sourceimpl FastInput
impl FastInput
sourcepub fn new() -> Self
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.
sourcepub fn with_buffer_size(buffer_size: usize) -> Self
pub fn with_buffer_size(buffer_size: usize) -> Self
Creates a new FastInput with a specified buffer size.
For more information, see [new
].
sourcepub fn with_reader<T: Read>(input: T) -> Self
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
].
sourcepub fn next_line(&self) -> &str
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
].
sourcepub fn next_parsed<'a, T: FParse<'a>>(&'a self) -> T
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);
sourcepub fn next_as_iter<'a, T: FParse<'a>>(&'a self) -> impl Iterator<Item = T> + '_
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
].
sourcepub fn next_split<'a>(&'a self) -> impl Iterator<Item = &'a str> + '_
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
].
sourcepub fn has_next_line(&self) -> bool
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());
}
sourcepub fn lines<'a>(&'a self) -> impl Iterator<Item = &'_ str> + 'a
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);
Trait Implementations
sourceimpl<'a, T1, T2, T3, T4, T5> FastParse<'a, (T1, T2, T3, T4, T5)> for FastInputwhere
T1: FParse<'a>,
T2: FParse<'a>,
T3: FParse<'a>,
T4: FParse<'a>,
T5: FParse<'a>,
impl<'a, T1, T2, T3, T4, T5> FastParse<'a, (T1, T2, T3, T4, T5)> for FastInputwhere
T1: FParse<'a>,
T2: FParse<'a>,
T3: FParse<'a>,
T4: FParse<'a>,
T5: FParse<'a>,
sourcefn next(&'a self) -> (T1, T2, T3, T4, T5)
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
].
sourceimpl<'a, T1, T2, T3, T4> FastParse<'a, (T1, T2, T3, T4)> for FastInputwhere
T1: FParse<'a>,
T2: FParse<'a>,
T3: FParse<'a>,
T4: FParse<'a>,
impl<'a, T1, T2, T3, T4> FastParse<'a, (T1, T2, T3, T4)> for FastInputwhere
T1: FParse<'a>,
T2: FParse<'a>,
T3: FParse<'a>,
T4: FParse<'a>,
sourcefn next(&'a self) -> (T1, T2, T3, T4)
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
].
sourceimpl<'a, T1, T2, T3> FastParse<'a, (T1, T2, T3)> for FastInputwhere
T1: FParse<'a>,
T2: FParse<'a>,
T3: FParse<'a>,
impl<'a, T1, T2, T3> FastParse<'a, (T1, T2, T3)> for FastInputwhere
T1: FParse<'a>,
T2: FParse<'a>,
T3: FParse<'a>,
sourcefn next(&'a self) -> (T1, T2, T3)
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
].
sourceimpl<'a, T1, T2> FastParse<'a, (T1, T2)> for FastInputwhere
T1: FParse<'a>,
T2: FParse<'a>,
impl<'a, T1, T2> FastParse<'a, (T1, T2)> for FastInputwhere
T1: FParse<'a>,
T2: FParse<'a>,
sourcefn next(&'a self) -> (T1, T2)
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
].