Struct Scanner 

pub struct Scanner<'a, I: Iterator<Item = &'a str> = SplitAsciiWhitespace<'a>> {
    iter: I,
}

Fields

iter: I

Implementations

impl<'a> Scanner<'a>

pub fn new(s: &'a str) -> Self

Examples found in repository

crates/aizu_online_judge/src/grl/grl_4_b.rs (line 13)

pub fn judge_grl_4_b(input: impl Read, _output: impl Read, result: impl Read) -> bool {
    let (s_in, s_res) = (read_all_unchecked(input), read_all_unchecked(result));
    let (mut scanner_in, mut scanner_res) = (Scanner::new(&s_in), Scanner::new(&s_res));
    scan!(scanner_in, vs, es, edges: [(usize, usize); iter es]);
    let mut ord = vec![!0usize; vs];
    let mut is_ac = true;
    for (i, u) in scanner_res.iter::<usize>().take(vs).enumerate() {
        is_ac &= ord[u] == !0usize;
        ord[u] = i;
    }
    for (u, v) in edges {
        is_ac &= ord[u] < ord[v];
    }
    is_ac
}

impl<'a, I: Iterator<Item = &'a str>> Scanner<'a, I>

pub fn new_from_iter(iter: I) -> Self

Examples found in repository

crates/competitive/src/tools/scanner.rs (line 539)

    fn mscan<I: ScanSource>(self, iter: &mut I) -> Option<Self::Output> {
        let mut iter = Scanner::new_from_iter(iter.next_token()?.split(self.pat));
        Some(from_fn(|| <T as Scan>::scan(&mut iter)).collect())
    }
}
impl<T> MarkedScan for Splitted<T, &str>
where
    T: Scan,
{
    type Output = Vec<<T as Scan>::Output>;
    fn mscan<I: ScanSource>(self, iter: &mut I) -> Option<Self::Output> {
        let mut iter = Scanner::new_from_iter(iter.next_token()?.split(self.pat));
        Some(from_fn(|| <T as Scan>::scan(&mut iter)).collect())
    }

Trait Implementations

impl<'a, I: Clone + Iterator<Item = &'a str>> Clone for Scanner<'a, I>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a, I: Debug + Iterator<Item = &'a str>> Debug for Scanner<'a, I>

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

Formats the value using the given formatter.

impl<'a, I: Iterator<Item = &'a str>> ScanSource for Scanner<'a, I>

fn next_token(&mut self) -> Option<&str>

Reads a token under the source’s input requirements. Checked sources return None at EOF; unchecked sources require available input.

fn skip_whitespace(&mut self)

Skips separators without consuming the next token.

fn read_u8(&mut self) -> Option<u8>

fn read_u16(&mut self) -> Option<u16>

fn read_u32(&mut self) -> Option<u32>

fn read_u64(&mut self) -> Option<u64>

fn read_u128(&mut self) -> Option<u128>

fn read_usize(&mut self) -> Option<usize>

fn read_i8(&mut self) -> Option<i8>

fn read_i16(&mut self) -> Option<i16>

fn read_i32(&mut self) -> Option<i32>

fn read_i64(&mut self) -> Option<i64>

fn read_i128(&mut self) -> Option<i128>

fn read_isize(&mut self) -> Option<isize>

fn scan<T: Scan>(&mut self) -> T::Output

Panics if reading fails.

fn mscan<T: MarkedScan>(&mut self, marker: T) -> T::Output

Panics if reading fails.

fn scan_vec<T: Scan>(&mut self, size: usize) -> Vec<T::Output>

fn iter<T: Scan>(&mut self) -> ScannerIter<'_, Self, T>