FilesExpand file tree

 master

/

scanner.rs

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

136 lines (117 loc) · 3.94 KB

 master

/

scanner.rs

Copy path

Top

File metadata and controls

• Code
• Blame

136 lines (117 loc) · 3.94 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

//! Generic utility for reading data from standard input, based on [voxl's

//! stdin wrapper](http://codeforces.com/contest/702/submission/19589375).

use std::io;

use std::str;

/// Reads white-space separated tokens one at a time.

pub struct Scanner<R> {

reader: R,

buffer: Vec<String>,

}

impl<R: io::BufRead> Scanner<R> {

pub fn new(reader: R) -> Self {

Self {

reader,

buffer: vec![],

}

}

/// Use "turbofish" syntax token::<T>() to select data type of next token.

///

/// # Panics

///

/// Panics if there's an I/O error or if the token cannot be parsed as T.

pub fn token<T: str::FromStr>(&mut self) -> T {

loop {

if let Some(token) = self.buffer.pop() {

return token.parse().ok().expect("Failed parse");

}

let mut input = String::new();

self.reader.read_line(&mut input).expect("Failed read");

self.buffer = input.split_whitespace().rev().map(String::from).collect();

}

}

}

/// Same API as Scanner but nearly twice as fast, using horribly unsafe dark arts

pub struct UnsafeScanner<R> {

reader: R,

buf_str: Vec<u8>,

buf_iter: str::SplitAsciiWhitespace<'static>,

}

impl<R: io::BufRead> UnsafeScanner<R> {

pub fn new(reader: R) -> Self {

Self {

reader,

buf_str: vec![],

buf_iter: "".split_ascii_whitespace(),

}

}

/// This function should be marked unsafe, but noone has time for that in a

/// programming contest. Use at your own risk!

pub fn token<T: str::FromStr>(&mut self) -> T {

loop {

if let Some(token) = self.buf_iter.next() {

return token.parse().ok().expect("Failed parse");

}

self.buf_str.clear();

self.reader

.read_until(b'\n', &mut self.buf_str)

.expect("Failed read");

self.buf_iter = unsafe {

let slice = str::from_utf8_unchecked(&self.buf_str);

std::mem::transmute(slice.split_ascii_whitespace())

}

}

}

}

pub fn scanner_from_file(filename: &str) -> Scanner<io::BufReader<std::fs::File>> {

let file = std::fs::File::open(filename).expect("Input file not found");

Scanner::new(io::BufReader::new(file))

}

pub fn writer_to_file(filename: &str) -> io::BufWriter<std::fs::File> {

let file = std::fs::File::create(filename).expect("Output file not found");

io::BufWriter::new(file)

}

#[cfg(test)]

mod test {

use super::*;

fn solve<R: io::BufRead, W: io::Write>(scan: &mut Scanner<R>, out: &mut W) {

let x = scan.token::<i32>();

let y = scan.token::<i32>();

writeln!(out, "{} - {} = {}", x, y, x - y).ok();

}

fn unsafe_solve<R: io::BufRead, W: io::Write>(scan: &mut UnsafeScanner<R>, out: &mut W) {

let x = scan.token::<i32>();

let y = scan.token::<i32>();

writeln!(out, "{} - {} = {}", x, y, x - y).ok();

}

#[test]

fn test_in_memory_io() {

let input: &[u8] = b"50 8";

let mut scan = Scanner::new(input);

let mut out = vec![];

solve(&mut scan, &mut out);

assert_eq!(out, b"50 - 8 = 42\n");

}

#[test]

fn test_in_memory_unsafe() {

let input: &[u8] = b"50 8";

let mut scan = UnsafeScanner::new(input);

let mut out = vec![];

unsafe_solve(&mut scan, &mut out);

assert_eq!(out, b"50 - 8 = 42\n");

}

#[test]

fn test_compile_stdio() {

let mut scan = Scanner::new(io::stdin().lock());

let mut out = io::BufWriter::new(io::stdout().lock());

if false {

solve(&mut scan, &mut out);

}

}

#[test]

#[should_panic(expected = "Input file not found")]

fn test_panic_file() {

let mut scan = scanner_from_file("input_file.txt");

let mut out = writer_to_file("output_file.txt");

solve(&mut scan, &mut out);

}

}