pub trait ScanSource: Sized {
Show 18 methods
// Required method
fn next_token(&mut self) -> Option<&str>;
// Provided methods
fn skip_whitespace(&mut self) { ... }
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 { ... }
fn mscan<T: MarkedScan>(&mut self, marker: T) -> T::Output { ... }
fn scan_vec<T: Scan>(&mut self, size: usize) -> Vec<T::Output> { ... }
fn iter<T: Scan>(&mut self) -> ScannerIter<'_, Self, T> ⓘ { ... }
}Required Methods§
Sourcefn next_token(&mut self) -> Option<&str>
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.
Provided Methods§
Sourcefn skip_whitespace(&mut self)
fn skip_whitespace(&mut self)
Skips separators without consuming the next token.
Examples found in repository?
crates/competitive/src/tools/scanner.rs (line 109)
107 fn scan_vec<T: Scan>(&mut self, size: usize) -> Vec<T::Output> {
108 if size == 0 {
109 self.skip_whitespace();
110 }
111 (0..size).map(|_| self.scan::<T>()).collect()
112 }
113 #[inline]
114 fn iter<T: Scan>(&mut self) -> ScannerIter<'_, Self, T> {
115 ScannerIter {
116 inner: self,
117 _marker: PhantomData,
118 }
119 }
120}
121
122#[derive(Clone, Debug)]
123pub struct Scanner<'a, I: Iterator<Item = &'a str> = std::str::SplitAsciiWhitespace<'a>> {
124 iter: I,
125}
126impl<'a> Scanner<'a> {
127 pub fn new(s: &'a str) -> Self {
128 Self {
129 iter: s.split_ascii_whitespace(),
130 }
131 }
132}
133impl<'a, I: Iterator<Item = &'a str>> Scanner<'a, I> {
134 pub fn new_from_iter(iter: I) -> Self {
135 Self { iter }
136 }
137}
138impl<'a, I: Iterator<Item = &'a str>> ScanSource for Scanner<'a, I> {
139 fn next_token(&mut self) -> Option<&str> {
140 self.iter.next()
141 }
142}
143
144macro_rules! impl_scan {
145 ($($t:ty)*) => {$(
146 impl Scan for $t {
147 type Output = Self;
148 fn scan<I: ScanSource>(iter: &mut I) -> Option<Self> {
149 iter.next_token()?.parse::<$t>().ok()
150 }
151 })*
152 };
153}
154impl_scan!(char f32 f64 String);
155
156macro_rules! impl_integer_scan {
157 ($($t:ty => $read:ident),* $(,)?) => {$(
158 impl Scan for $t {
159 type Output = Self;
160 #[inline]
161 fn scan<S: ScanSource>(source: &mut S) -> Option<Self> {
162 source.$read()
163 }
164 }
165 )*};
166}
167impl_integer_scan!(
168 u8 => read_u8, u16 => read_u16, u32 => read_u32, u64 => read_u64,
169 u128 => read_u128, usize => read_usize, i8 => read_i8, i16 => read_i16,
170 i32 => read_i32, i64 => read_i64, i128 => read_i128, isize => read_isize,
171);
172
173macro_rules! impl_scan_tuple {
174 (@impl $($T:ident)*) => {
175 impl<$($T: Scan),*> Scan for ($($T,)*) {
176 type Output = ($(<$T as Scan>::Output,)*);
177 fn scan<It: ScanSource>(_iter: &mut It) -> Option<Self::Output> {
178 Some(($(<$T as Scan>::scan(_iter)?,)*))
179 }
180 }
181 };
182 (@inner $($T:ident)*,) => {
183 impl_scan_tuple!(@impl $($T)*);
184 };
185 (@inner $($T:ident)*, $U:ident $($Rest:ident)*) => {
186 impl_scan_tuple!(@impl $($T)*);
187 impl_scan_tuple!(@inner $($T)* $U, $($Rest)*);
188 };
189 ($($T:ident)*) => {
190 impl_scan_tuple!(@inner , $($T)*);
191 };
192}
193impl_scan_tuple!(A B C D E F G H I J K);
194
195pub struct ScannerIter<'a, S, T> {
196 inner: &'a mut S,
197 _marker: PhantomData<fn() -> T>,
198}
199impl<S: ScanSource, T: Scan> Iterator for ScannerIter<'_, S, T> {
200 type Item = T::Output;
201 #[inline]
202 fn next(&mut self) -> Option<Self::Item> {
203 T::scan(self.inner)
204 }
205}
206
207/// scan a value with Scanner
208///
209/// - `scan_value!(scanner, ELEMENT)`
210///
211/// ELEMENT :=
212/// - `$ty`: Scan
213/// - `&str`: borrowed token; the source stays borrowed until its last use
214/// - `@$expr`: MarkedScan
215/// - `$ty = $expr`: MarkedScan
216/// - `[ELEMENT; $expr]`: vector
217/// - `[ELEMENT; const $expr]`: array
218/// - `[ELEMENT]`: iterator
219/// - `[ELEMENT; iter $expr]`: iterator of the specified length
220/// - `($(ELEMENT)*,)`: tuple
221#[macro_export]
222macro_rules! scan_value {
223 (@repeat $scanner:expr, [$($t:tt)*] $len:expr) => { { $crate::scan_value!(@iter $scanner, [$($t)*] $len).collect::<Vec<_>>() } };
224 (@repeat $scanner:expr, [$($t:tt)*]) => { { ::std::iter::repeat_with(|| $crate::scan_value!(@inner $scanner, [] $($t)*)) } };
225 (@iter $scanner:expr, [$($t:tt)*] $len:expr) => {{ let size = $len; if size == 0 { $scanner.skip_whitespace(); } $crate::scan_value!(@repeat $scanner, [$($t)*]).take(size) }};
226 (@array $scanner:expr, [$($t:tt)*] $len:expr) => { { if $len == 0 { $scanner.skip_whitespace(); } $crate::array![|| $crate::scan_value!(@inner $scanner, [] $($t)*); $len] } };
227 (@tuple $scanner:expr, [$([$($args:tt)*])*]) => { ($($($args)*,)*) };
228 (@sparen $scanner:expr, [] @$e:expr; $($t:tt)*) => { $crate::scan_value!(@sparen $scanner, [@$e] $($t)*) };
229 (@sparen $scanner:expr, [] ($($tt:tt)*); $($t:tt)*) => { $crate::scan_value!(@sparen $scanner, [($($tt)*)] $($t)*) };
230 (@sparen $scanner:expr, [] [$($tt:tt)*]; $($t:tt)*) => { $crate::scan_value!(@sparen $scanner, [[$($tt)*]] $($t)*) };
231 (@sparen $scanner:expr, [] $ty:ty = $e:expr; $($t:tt)*) => { $crate::scan_value!(@sparen $scanner, [$ty = $e] $($t)*) };
232 (@sparen $scanner:expr, [] $ty:ty; $($t:tt)*) => { $crate::scan_value!(@sparen $scanner, [$ty] $($t)*) };
233 (@sparen $scanner:expr, [] $($args:tt)*) => { $crate::scan_value!(@repeat $scanner, [$($args)*]) };
234 (@sparen $scanner:expr, [$($args:tt)+] const $len:expr) => { $crate::scan_value!(@array $scanner, [$($args)+] $len) };
235 (@sparen $scanner:expr, [$($args:tt)+] iter $len:expr) => { $crate::scan_value!(@iter $scanner, [$($args)+] $len) };
236 (@sparen $scanner:expr, [$($args:tt)+] $len:expr) => { $crate::scan_value!(@repeat $scanner, [$($args)+] $len) };
237 (@$tag:ident $scanner:expr, [[$($args:tt)*]]) => { $($args)* };
238 (@$tag:ident $scanner:expr, [$($args:tt)*] @$e:expr $(, $($t:tt)*)?) => { $crate::scan_value!(@$tag $scanner, [$($args)* [$scanner.mscan($e)]] $(, $($t)*)?) };
239 (@$tag:ident $scanner:expr, [$($args:tt)*] ($($tuple:tt)*) $($t:tt)*) => { $crate::scan_value!(@$tag $scanner, [$($args)* [$crate::scan_value!(@tuple $scanner, [] $($tuple)*)]] $($t)*) };
240 (@$tag:ident $scanner:expr, [$($args:tt)*] [$($tt:tt)*] $($t:tt)*) => { $crate::scan_value!(@$tag $scanner, [$($args)* [$crate::scan_value!(@sparen $scanner, [] $($tt)*)]] $($t)*) };
241 (@$tag:ident $scanner:expr, [$($args:tt)*] &str $(, $($t:tt)*)?) => { $crate::scan_value!(@$tag $scanner, [$($args)* [$scanner.next_token().expect("scan error")]] $(, $($t)*)?) };
242 (@$tag:ident $scanner:expr, [$($args:tt)*] $ty:ty = $e:expr $(, $($t:tt)*)?) => { $crate::scan_value!(@$tag $scanner, [$($args)* [{ let _tmp: $ty = $scanner.mscan($e); _tmp }]] $(, $($t)*)?) };
243 (@$tag:ident $scanner:expr, [$($args:tt)*] $ty:ty $(, $($t:tt)*)?) => { $crate::scan_value!(@$tag $scanner, [$($args)* [$scanner.scan::<$ty>()]] $(, $($t)*)?) };
244 (@$tag:ident $scanner:expr, [$($args:tt)*] , $($t:tt)*) => { $crate::scan_value!(@$tag $scanner, [$($args)*] $($t)*) };
245 (@$tag:ident $scanner:expr, [$($args:tt)*]) => { ::std::compile_error!(::std::stringify!($($args)*)) };
246 (src = $src:expr, $($t:tt)*) => { { let mut __scanner = Scanner::new($src); $crate::scan_value!(@inner __scanner, [] $($t)*) } };
247 (iter = $iter:expr, $($t:tt)*) => { { let mut __scanner = Scanner::new_from_iter($iter); $crate::scan_value!(@inner __scanner, [] $($t)*) } };
248 ($scanner:expr, $($t:tt)*) => { $crate::scan_value!(@inner $scanner, [] $($t)*) }
249}
250
251/// scan and bind values with Scanner
252///
253/// - `scan!(scanner, $($pat $(: ELEMENT)?),*)`
254#[macro_export]
255macro_rules! scan {
256 (@assert $p:pat) => {};
257 (@assert $($p:tt)*) => { ::std::compile_error!(::std::concat!("expected pattern, found `", ::std::stringify!($($p)*), "`")); };
258 (@pat $scanner:expr, [] []) => {};
259 (@pat $scanner:expr, [] [] , $($t:tt)*) => { $crate::scan!(@pat $scanner, [] [] $($t)*) };
260 (@pat $scanner:expr, [$($p:tt)*] [] $x:ident $($t:tt)*) => { $crate::scan!(@pat $scanner, [$($p)* $x] [] $($t)*) };
261 (@pat $scanner:expr, [$($p:tt)*] [] :: $($t:tt)*) => { $crate::scan!(@pat $scanner, [$($p)* ::] [] $($t)*) };
262 (@pat $scanner:expr, [$($p:tt)*] [] & $($t:tt)*) => { $crate::scan!(@pat $scanner, [$($p)* &] [] $($t)*) };
263 (@pat $scanner:expr, [$($p:tt)*] [] ($($x:tt)*) $($t:tt)*) => { $crate::scan!(@pat $scanner, [$($p)* ($($x)*)] [] $($t)*) };
264 (@pat $scanner:expr, [$($p:tt)*] [] [$($x:tt)*] $($t:tt)*) => { $crate::scan!(@pat $scanner, [$($p)* [$($x)*]] [] $($t)*) };
265 (@pat $scanner:expr, [$($p:tt)*] [] {$($x:tt)*} $($t:tt)*) => { $crate::scan!(@pat $scanner, [$($p)* {$($x)*}] [] $($t)*) };
266 (@pat $scanner:expr, [$($p:tt)*] [] : $($t:tt)*) => { $crate::scan!(@ty $scanner, [$($p)*] [] $($t)*) };
267 (@pat $scanner:expr, [$($p:tt)*] [] $($t:tt)*) => { $crate::scan!(@let $scanner, [$($p)*] [usize] $($t)*) };
268 (@ty $scanner:expr, [$($p:tt)*] [$($tt:tt)*] @$e:expr $(, $($t:tt)*)?) => { $crate::scan!(@let $scanner, [$($p)*] [$($tt)* @$e] $(, $($t)*)?) };
269 (@ty $scanner:expr, [$($p:tt)*] [$($tt:tt)*] ($($x:tt)*) $($t:tt)*) => { $crate::scan!(@let $scanner, [$($p)*] [$($tt)* ($($x)*)] $($t)*) };
270 (@ty $scanner:expr, [$($p:tt)*] [$($tt:tt)*] [$($x:tt)*] $($t:tt)*) => { $crate::scan!(@let $scanner, [$($p)*] [$($tt)* [$($x)*]] $($t)*) };
271 (@ty $scanner:expr, [$($p:tt)*] [$($tt:tt)*] &str $(, $($t:tt)*)?) => { $crate::scan!(@let $scanner, [$($p)*] [$($tt)* &str] $(, $($t)*)?) };
272 (@ty $scanner:expr, [$($p:tt)*] [$($tt:tt)*] $ty:ty = $e:expr $(, $($t:tt)*)?) => { $crate::scan!(@let $scanner, [$($p)*] [$($tt)* $ty = $e] $(, $($t)*)?) };
273 (@ty $scanner:expr, [$($p:tt)*] [$($tt:tt)*] $ty:ty $(, $($t:tt)*)?) => { $crate::scan!(@let $scanner, [$($p)*] [$($tt)* $ty] $(, $($t)*)?) };
274 (@let $scanner:expr, [$($p:tt)*] [$($tt:tt)*] $($t:tt)*) => {
275 $crate::scan!{@assert $($p)*}
276 let $($p)* = $crate::scan_value!($scanner, $($tt)*);
277 $crate::scan!(@pat $scanner, [] [] $($t)*)
278 };
279 (src = $src:expr, $($t:tt)*) => { let mut __scanner = Scanner::new($src); $crate::scan!(@pat __scanner, [] [] $($t)*) };
280 (iter = $iter:expr, $($t:tt)*) => { let mut __scanner = Scanner::new_from_iter($iter); $crate::scan!(@pat __scanner, [] [] $($t)*) };
281 ($scanner:expr, $($t:tt)*) => { $crate::scan!(@pat $scanner, [] [] $($t)*) }
282}
283
284/// define enum scan rules
285///
286/// # Example
287/// ```rust
288/// # use competitive::{define_enum_scan, tools::{CharsWithBase, Scan, ScanSource, Scanner, Usize1}};
289/// define_enum_scan! {
290/// enum Query: u8 {
291/// 0 => Noop,
292/// 1 => Args { i: Usize1, s: char },
293/// 9 => Complex { n: usize, c: [(usize, Vec<usize> = CharsWithBase('a')); n] },
294/// }
295/// }
296/// ```
297#[macro_export]
298macro_rules! define_enum_scan {
299 (@field_ty @repeat [$($t:tt)*] $($len:expr)?) => { Vec<$crate::define_enum_scan!(@field_ty $($t)*)> };
300 (@field_ty @array [$($t:tt)*] $len:expr) => { [$crate::define_enum_scan!(@field_ty $($t)*); $len] };
301 (@field_ty @tuple [$([$($args:tt)*])*]) => { ($( $($args)* ,)*) };
302 (@field_ty @sparen [] ($($tt:tt)*); $($t:tt)*) => { $crate::define_enum_scan!(@field_ty @sparen [($($tt)*)] $($t)*) };
303 (@field_ty @sparen [] [$($tt:tt)*]; $($t:tt)*) => { $crate::define_enum_scan!(@field_ty @sparen [[$($tt)*]] $($t)*) };
304 (@field_ty @sparen [] $ty:ty = $e:expr; $($t:tt)*) => { $crate::define_enum_scan!(@field_ty @sparen [$ty = $e] $($t)*) };
305 (@field_ty @sparen [] $ty:ty; $($t:tt)*) => { $crate::define_enum_scan!(@field_ty @sparen [$ty] $($t)*) };
306 (@field_ty @sparen [] $($args:tt)*) => { $crate::define_enum_scan!(@field_ty @repeat [$($args)*]) };
307 (@field_ty @sparen [$($args:tt)+] const $len:expr) => { $crate::define_enum_scan!(@field_ty @array [$($args)+] $len) };
308 (@field_ty @sparen [$($args:tt)+] $len:expr) => { $crate::define_enum_scan!(@field_ty @repeat [$($args)+] $len) };
309 (@field_ty @$tag:ident [$($args:tt)*] ($($tuple:tt)*) $($t:tt)*) => { $crate::define_enum_scan!(@field_ty @$tag [$($args)* [$crate::define_enum_scan!(@field_ty @tuple [] $($tuple)*)]] $($t)*) };
310 (@field_ty @$tag:ident [$($args:tt)*] [$($tt:tt)*] $($t:tt)*) => { $crate::define_enum_scan!(@field_ty @$tag [$($args)* [$crate::define_enum_scan!(@field_ty @sparen [] $($tt)*)]] $($t)*) };
311 (@field_ty @$tag:ident [$($args:tt)*] $ty:ty = $e:expr $(, $($t:tt)*)?) => { $crate::define_enum_scan!(@field_ty @$tag [$($args)* [$ty]] $(, $($t)*)?) };
312 (@field_ty @$tag:ident [$($args:tt)*] $ty:ty $(, $($t:tt)*)?) => { $crate::define_enum_scan!(@field_ty @$tag [$($args)* [<$ty as Scan>::Output]] $(, $($t)*)?) };
313 (@field_ty @$tag:ident [$($args:tt)*] , $($t:tt)*) => { $crate::define_enum_scan!(@field_ty @$tag [$($args)*] $($t)*) };
314 (@field_ty @$tag:ident [[$($args:tt)*]]) => { $($args)* };
315 (@field_ty @$tag:ident [$($args:tt)*]) => { ::std::compile_error!(::std::stringify!($($args)*)) };
316 (@field_ty $($t:tt)*) => { $crate::define_enum_scan!(@field_ty @inner [] $($t)*) };
317
318 (@tag_expr raw, $iter:ident) => { ScanSource::next_token($iter)? };
319 (@tag_expr $d:ty, $iter:ident) => { <$d as Scan>::scan($iter)? };
320 (@variant ([$($attr:tt)*] $vis:vis $T:ident $d:tt) [$($vars:tt)*]) => { $crate::define_enum_scan! { @def $($attr)* $vis enum $T : $d { $($vars)* } } };
321 (@variant $ctx:tt [$($vars:tt)*] $p:pat => $v:ident { $($fs:tt)* } $($rest:tt)*) => { $crate::define_enum_scan! { @field $ctx [$($vars)*] $p => $v [] $($fs)* ; $($rest)* } };
322 (@variant $ctx:tt [$($vars:tt)*] $p:pat => $v:ident $($rest:tt)*) => { $crate::define_enum_scan! { @variant $ctx [$($vars)* $p => $v ,] $($rest)* } };
323 (@variant $ctx:tt [$($vars:tt)*] , $($rest:tt)*) => { $crate::define_enum_scan! { @variant $ctx [$($vars)*] $($rest)* } };
324 (@endfield $ctx:tt [$($vars:tt)*] $p:pat => $v:ident [$($fs:tt)*] [$f:ident : $($spec:tt)*] , $($rest:tt)*) => { $crate::define_enum_scan! { @field $ctx [$($vars)*] $p => $v [$($fs)* [$f : $($spec)*]] $($rest)* } };
325 (@endfield $ctx:tt [$($vars:tt)*] $p:pat => $v:ident [$($fs:tt)*] [$f:ident : $($spec:tt)*] ; $($rest:tt)*) => { $crate::define_enum_scan! { @variant $ctx [$($vars)* $p => $v { $($fs)* [$f : $($spec)*] } ,] $($rest)* } };
326 (@field $ctx:tt [$($vars:tt)*] $p:pat => $v:ident [$($fs:tt)*] ; $($rest:tt)*) => { $crate::define_enum_scan! { @variant $ctx [$($vars)* $p => $v { $($fs)* } ,] $($rest)* } };
327 (@field $ctx:tt [$($vars:tt)*] $p:pat => $v:ident [$($fs:tt)*] $f:ident : ($($tuple:tt)*) $sep:tt $($rest:tt)*) => { $crate::define_enum_scan! { @endfield $ctx [$($vars)*] $p => $v [$($fs)*] [$f : ($($tuple)*)] $sep $($rest)* } };
328 (@field $ctx:tt [$($vars:tt)*] $p:pat => $v:ident [$($fs:tt)*] $f:ident : [$($x:tt)*] $sep:tt $($rest:tt)*) => { $crate::define_enum_scan! { @endfield $ctx [$($vars)*] $p => $v [$($fs)*] [$f : [$($x)*]] $sep $($rest)* } };
329 (@field $ctx:tt [$($vars:tt)*] $p:pat => $v:ident [$($fs:tt)*] $f:ident : $ty:ty = $e:expr , $($rest:tt)*) => { $crate::define_enum_scan! { @endfield $ctx [$($vars)*] $p => $v [$($fs)*] [$f : $ty = $e] , $($rest)* } };
330 (@field $ctx:tt [$($vars:tt)*] $p:pat => $v:ident [$($fs:tt)*] $f:ident : $ty:ty ; $($rest:tt)*) => { $crate::define_enum_scan! { @endfield $ctx [$($vars)*] $p => $v [$($fs)*] [$f : $ty] ; $($rest)* } };
331 (@field $ctx:tt [$($vars:tt)*] $p:pat => $v:ident [$($fs:tt)*] $f:ident : $ty:ty = $e:expr ; $($rest:tt)*) => { $crate::define_enum_scan! { @endfield $ctx [$($vars)*] $p => $v [$($fs)*] [$f : $ty = $e] ; $($rest)* } };
332 (@field $ctx:tt [$($vars:tt)*] $p:pat => $v:ident [$($fs:tt)*] $f:ident : $ty:ty , $($rest:tt)*) => { $crate::define_enum_scan! { @endfield $ctx [$($vars)*] $p => $v [$($fs)*] [$f : $ty] , $($rest)* } };
333 (
334 @def
335 $(#[$attr:meta])*
336 $vis:vis enum $T:ident : $d:tt {
337 $( $p:pat => $v:ident $( { $( [$f:ident : $($spec:tt)*] )* } )?, )*
338 }
339 ) => {
340 $(#[$attr])*
341 $vis enum $T {
342 $( $v $( { $( $f : $crate::define_enum_scan!(@field_ty $($spec)*) ),* } )? ),*
343 }
344 impl Scan for $T {
345 type Output = Self;
346 fn scan<I: ScanSource>(iter: &mut I) -> Option<Self> {
347 let tag = $crate::define_enum_scan!(@tag_expr $d, iter);
348 match tag {
349 $(
350 $p => {
351 $($(
352 let $f = $crate::scan_value!((*iter), $($spec)* );
353 )*)?
354 Some($T::$v $( { $( $f ),* } )?)
355 }
356 ),*
357 _ => None,
358 }
359 }
360 }
361 };
362 (
363 $(#[$attr:meta])*
364 $vis:vis enum $T:ident : raw {
365 $($body:tt)*
366 }
367 ) => {
368 $crate::define_enum_scan! { @variant ([$(#[$attr])*] $vis $T raw) [] $($body)* }
369 };
370 (
371 $(#[$attr:meta])*
372 $vis:vis enum $T:ident : $d:ty {
373 $($body:tt)*
374 }
375 ) => {
376 $crate::define_enum_scan! { @variant ([$(#[$attr])*] $vis $T $d) [] $($body)* }
377 };
378}
379
380#[derive(Debug, Copy, Clone)]
381pub enum Usize1 {}
382impl Scan for Usize1 {
383 type Output = usize;
384 fn scan<I: ScanSource>(iter: &mut I) -> Option<Self::Output> {
385 <usize as Scan>::scan(iter)?.checked_sub(1)
386 }
387}
388#[derive(Debug, Copy, Clone)]
389pub struct CharWithBase(pub char);
390impl MarkedScan for CharWithBase {
391 type Output = usize;
392 fn mscan<I: ScanSource>(self, iter: &mut I) -> Option<Self::Output> {
393 Some((<char as Scan>::scan(iter)? as u8 - self.0 as u8) as usize)
394 }
395}
396#[derive(Debug, Copy, Clone)]
397pub enum Chars {}
398impl Scan for Chars {
399 type Output = Vec<char>;
400 fn scan<I: ScanSource>(iter: &mut I) -> Option<Self::Output> {
401 Some(iter.next_token()?.chars().collect())
402 }
403}
404#[derive(Debug, Copy, Clone)]
405pub struct CharsWithBase(pub char);
406impl MarkedScan for CharsWithBase {
407 type Output = Vec<usize>;
408 fn mscan<I: ScanSource>(self, iter: &mut I) -> Option<Self::Output> {
409 Some(
410 iter.next_token()?
411 .chars()
412 .map(|c| (c as u8 - self.0 as u8) as usize)
413 .collect(),
414 )
415 }
416}
417#[derive(Debug, Copy, Clone)]
418pub enum Byte1 {}
419impl Scan for Byte1 {
420 type Output = u8;
421 fn scan<I: ScanSource>(iter: &mut I) -> Option<Self::Output> {
422 let bytes = iter.next_token()?.as_bytes();
423 assert_eq!(bytes.len(), 1);
424 Some(bytes[0])
425 }
426}
427#[derive(Debug, Copy, Clone)]
428pub struct ByteWithBase(pub u8);
429impl MarkedScan for ByteWithBase {
430 type Output = usize;
431 fn mscan<I: ScanSource>(self, iter: &mut I) -> Option<Self::Output> {
432 Some((<char as Scan>::scan(iter)? as u8 - self.0) as usize)
433 }
434}
435#[derive(Debug, Copy, Clone)]
436pub enum Bytes {}
437impl Scan for Bytes {
438 type Output = Vec<u8>;
439 fn scan<I: ScanSource>(iter: &mut I) -> Option<Self::Output> {
440 Some(iter.next_token()?.bytes().collect())
441 }
442}
443#[derive(Debug, Copy, Clone)]
444pub struct BytesWithBase(pub u8);
445impl MarkedScan for BytesWithBase {
446 type Output = Vec<usize>;
447 fn mscan<I: ScanSource>(self, iter: &mut I) -> Option<Self::Output> {
448 Some(
449 iter.next_token()?
450 .bytes()
451 .map(|c| (c - self.0) as usize)
452 .collect(),
453 )
454 }
455}
456#[derive(Debug, Copy, Clone)]
457pub struct Collect<T, B = Vec<<T as Scan>::Output>>
458where
459 T: Scan,
460 B: FromIterator<<T as Scan>::Output>,
461{
462 size: usize,
463 _marker: PhantomData<fn() -> (T, B)>,
464}
465impl<T, B> Collect<T, B>
466where
467 T: Scan,
468 B: FromIterator<<T as Scan>::Output>,
469{
470 pub fn new(size: usize) -> Self {
471 Self {
472 size,
473 _marker: PhantomData,
474 }
475 }
476}
477impl<T, B> MarkedScan for Collect<T, B>
478where
479 T: Scan,
480 B: FromIterator<<T as Scan>::Output>,
481{
482 type Output = B;
483 fn mscan<I: ScanSource>(self, iter: &mut I) -> Option<Self::Output> {
484 if self.size == 0 {
485 iter.skip_whitespace();
486 }
487 repeat_with(|| <T as Scan>::scan(iter))
488 .take(self.size)
489 .collect()
490 }
491}
492#[derive(Debug, Copy, Clone)]
493pub struct SizedCollect<T, B = Vec<<T as Scan>::Output>>
494where
495 T: Scan,
496 B: FromIterator<<T as Scan>::Output>,
497{
498 _marker: PhantomData<fn() -> (T, B)>,
499}
500impl<T, B> Scan for SizedCollect<T, B>
501where
502 T: Scan,
503 B: FromIterator<<T as Scan>::Output>,
504{
505 type Output = B;
506 fn scan<I: ScanSource>(iter: &mut I) -> Option<Self::Output> {
507 let size = usize::scan(iter)?;
508 if size == 0 {
509 iter.skip_whitespace();
510 }
511 repeat_with(|| <T as Scan>::scan(iter)).take(size).collect()
512 }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>
Sourcefn mscan<T: MarkedScan>(&mut self, marker: T) -> T::Output
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>
Sourcefn iter<T: Scan>(&mut self) -> ScannerIter<'_, Self, T> ⓘ
fn iter<T: Scan>(&mut self) -> ScannerIter<'_, Self, T> ⓘ
Examples found in repository?
crates/aizu_online_judge/src/grl/grl_4_b.rs (line 17)
11pub fn judge_grl_4_b(input: impl Read, _output: impl Read, result: impl Read) -> bool {
12 let (s_in, s_res) = (read_all_unchecked(input), read_all_unchecked(result));
13 let (mut scanner_in, mut scanner_res) = (Scanner::new(&s_in), Scanner::new(&s_res));
14 scan!(scanner_in, vs, es, edges: [(usize, usize); iter es]);
15 let mut ord = vec![!0usize; vs];
16 let mut is_ac = true;
17 for (i, u) in scanner_res.iter::<usize>().take(vs).enumerate() {
18 is_ac &= ord[u] == !0usize;
19 ord[u] = i;
20 }
21 for (u, v) in edges {
22 is_ac &= ord[u] < ord[v];
23 }
24 is_ac
25}Dyn Compatibility§
This trait is not dyn compatible.
In older versions of Rust, dyn compatibility was called "object safety".