1#![allow(non_snake_case)]
2
3use std::io;
4
5pub fn get_u8_input(message: &str) -> u8 {
6 println!("{}", message);
7 let mut userInput = String::new();
8 loop {
9 io::stdin().read_line(&mut userInput).expect("Failed to read line");
10 match userInput.trim().parse::<u8>() {
11 Ok(value) => {return value;}
12 Err(e) => {
13 println!("\nInvalid input! Error: {}", e);
14 userInput = String::new();
15 }
16 }
17 }
18}
19
20pub fn get_u32_input(message: &str) -> u32 {
21 println!("{}", message);
22 let mut userInput = String::new();
23 loop {
24 io::stdin().read_line(&mut userInput).expect("Failed to read line");
25 match userInput.trim().parse::<u32>() {
26 Ok(value) => {return value;}
27 Err(e) => {
28 println!("\nInvalid input! Error: {}", e);
29 userInput = String::new();
30 }
31 }
32 }
33}
34
35pub fn get_u64_input(message: &str) -> u64 {
36 println!("{}", message);
37 let mut userInput = String::new();
38 loop {
39 io::stdin().read_line(&mut userInput).expect("Failed to read line");
40 match userInput.trim().parse::<u64>() {
41 Ok(value) => {return value;}
42 Err(e) => {
43 println!("\nInvalid input! Error: {}", e);
44 userInput = String::new();
45 }
46 }
47 }
48}
49
50pub fn get_u128_input(message: &str) -> u128 {
51 println!("{}", message);
52 let mut userInput = String::new();
53 loop {
54 io::stdin().read_line(&mut userInput).expect("Failed to read line");
55 match userInput.trim().parse::<u128>() {
56 Ok(value) => {return value;}
57 Err(e) => {
58 println!("\nInvalid input! Error: {}", e);
59 userInput = String::new();
60 }
61 }
62 }
63}
64
65pub fn get_usize_input(message: &str) -> usize {
66 println!("{}", message);
67 let mut userInput = String::new();
68 loop {
69 io::stdin().read_line(&mut userInput).expect("Failed to read line");
70 match userInput.trim().parse::<usize>() {
71 Ok(value) => {return value;}
72 Err(e) => {
73 println!("\nInvalid input! Error: {}", e);
74 userInput = String::new();
75 }
76 }
77 }
78}
79
80pub fn get_i8_input(message: &str) -> i8 {
81 println!("{}", message);
82 let mut userInput = String::new();
83 loop {
84 io::stdin().read_line(&mut userInput).expect("Failed to read line");
85 match userInput.trim().parse::<i8>() {
86 Ok(value) => {return value;}
87 Err(e) => {
88 println!("\nInvalid input! Error: {}", e);
89 userInput = String::new();
90 }
91 }
92 }
93}
94
95pub fn get_i32_input(message: &str) -> i32 {
96 println!("{}", message);
97 let mut userInput = String::new();
98 loop {
99 io::stdin().read_line(&mut userInput).expect("Failed to read line");
100 match userInput.trim().parse::<i32>() {
101 Ok(value) => {return value;}
102 Err(e) => {
103 println!("\nInvalid input! Error: {}", e);
104 userInput = String::new();
105 }
106 }
107 }
108}
109
110pub fn get_i64_input(message: &str) -> i64 {
111 println!("{}", message);
112 let mut userInput = String::new();
113 loop {
114 io::stdin().read_line(&mut userInput).expect("Failed to read line");
115 match userInput.trim().parse::<i64>() {
116 Ok(value) => {return value;}
117 Err(e) => {
118 println!("\nInvalid input! Error: {}", e);
119 userInput = String::new();
120 }
121 }
122 }
123}
124
125pub fn get_i128_input(message: &str) -> i128 {
126 println!("{}", message);
127 let mut userInput = String::new();
128 loop {
129 io::stdin().read_line(&mut userInput).expect("Failed to read line");
130 match userInput.trim().parse::<i128>() {
131 Ok(value) => {return value;}
132 Err(e) => {
133 println!("\nInvalid input! Error: {}", e);
134 userInput = String::new();
135 }
136 }
137 }
138}
139
140pub fn get_isize_input(message: &str) -> isize {
141 println!("{}", message);
142 let mut userInput = String::new();
143 loop {
144 io::stdin().read_line(&mut userInput).expect("Failed to read line");
145 match userInput.trim().parse::<isize>() {
146 Ok(value) => {return value;}
147 Err(e) => {
148 println!("\nInvalid input! Error: {}", e);
149 userInput = String::new();
150 }
151 }
152 }
153}
154
155pub fn get_f32_input(message: &str) -> f32 {
156 println!("{}", message);
157 let mut userInput = String::new();
158 loop {
159 io::stdin().read_line(&mut userInput).expect("Failed to read line");
160 match userInput.trim().parse::<f32>() {
161 Ok(value) => {return value;}
162 Err(e) => {
163 println!("\nInvalid input! Error: {}", e);
164 userInput = String::new();
165 }
166 }
167 }
168}
169
170pub fn get_f64_input(message: &str) -> f64 {
171 println!("{}", message);
172 let mut userInput = String::new();
173 loop {
174 io::stdin().read_line(&mut userInput).expect("Failed to read line");
175 match userInput.trim().parse::<f64>() {
176 Ok(value) => {return value;}
177 Err(e) => {
178 println!("\nInvalid input! Error: {}", e);
179 userInput = String::new();
180 }
181 }
182 }
183}
184
185pub fn get_bool_input(message: &str) -> bool {
186 println!("{}", message);
187 let mut userInput = String::new();
188 loop {
189 io::stdin().read_line(&mut userInput).expect("Failed to read line");
190 match userInput.trim().parse::<bool>() {
191 Ok(value) => {return value;}
192 Err(e) => {
193 println!("\nInvalid input! Error: {}", e);
194 userInput = String::new();
195 }
196 }
197 }
198}
199
200pub fn get_char_input(message: &str) -> char {
201 println!("{}", message);
202 let mut userInput = String::new();
203 loop {
204 io::stdin().read_line(&mut userInput).expect("Failed to read line");
205 match userInput.trim().parse::<char>() {
206 Ok(value) => {return value;}
207 Err(e) => {
208 println!("\nInvalid input! Error: {}", e);
209 userInput = String::new();
210 }
211 }
212 }
213}
214
215pub fn get_string_input(message: &str) -> String {
216 println!("{}", message);
217 let mut userInput = String::new();
218 loop {
219 io::stdin().read_line(&mut userInput).expect("Failed to read line");
220 match userInput.trim().parse::<String>() {
221 Ok(value) => {return value;}
222 Err(e) => {
223 println!("\nInvalid input! Error: {}", e);
224 userInput = String::new();
225 }
226 }
227 }
228}