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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158


#[doc="created function to reuse and reduce LOC for f32 input."]
#[allow(dead_code)]
pub fn as_f32(message:&str)->(f32){
println!("{}",message);
let mut input = String::new();
std::io::stdin().read_line(&mut input).expect("Input Failed");
let float: f32 = input.trim().parse().unwrap();
float
}

#[doc="created function to reuse and reduce LOC for i32 input."]
#[allow(dead_code)]
pub fn as_i32(message:&str)->(i32){
println!("{}",message);
let mut input = String::new();
std::io::stdin().read_line(&mut input).expect("Input Failed");
let integer: i32 = input.trim().parse().unwrap();
integer
}



#[doc="created function to reuse and reduce LOC for string input."]
#[allow(dead_code)]
pub fn as_string(message:&str)->(String){
println!("{}",message);
let mut input = String::new();
std::io::stdin().read_line(&mut input).expect("Input Failed");
input
}


#[doc="created function to reuse and reduce LOC for isize input."]
#[allow(dead_code)]
pub fn as_isize(message:&str)->(isize){
println!("{}",message);
let mut input = String::new();
std::io::stdin().read_line(&mut input).expect("Input Failed");
let integer: isize = input.trim().parse().unwrap();
integer
}


#[doc="created function to reuse and reduce LOC for usize input."]
#[allow(dead_code)]
pub fn as_usize(message:&str)->(usize){
println!("{}",message);
let mut input = String::new();
std::io::stdin().read_line(&mut input).expect("Input Failed");
let integer: usize = input.trim().parse().unwrap();
integer
}

#[doc="created function to reuse and reduce LOC for u8 input."]
#[allow(dead_code)]
pub fn as_u8(message:&str)->(u8){
println!("{}",message);
let mut input = String::new();
std::io::stdin().read_line(&mut input).expect("Input Failed");
let integer: u8 = input.trim().parse().unwrap();
integer
}

#[doc="created function to reuse and reduce LOC for u16 input."]
#[allow(dead_code)]
pub fn as_u16(message:&str)->(u16){
println!("{}",message);
let mut input = String::new();
std::io::stdin().read_line(&mut input).expect("Input Failed");
let integer: u16 = input.trim().parse().unwrap();
integer
}


#[doc="created function to reuse and reduce LOC for i8 input."]
#[allow(dead_code)]
pub fn as_i8(message:&str)->(i8){
println!("{}",message);
let mut input = String::new();
std::io::stdin().read_line(&mut input).expect("Input Failed");
let integer: i8 = input.trim().parse().unwrap();
integer
}

#[doc="created function to reuse and reduce LOC for i16 input."]
#[allow(dead_code)]
pub fn as_i16(message:&str)->(i16){
println!("{}",message);
let mut input = String::new();
std::io::stdin().read_line(&mut input).expect("Input Failed");
let integer: i16 = input.trim().parse().unwrap();
integer
}

#[doc="created function to reuse and reduce LOC for u32 input."]
#[allow(dead_code)]
pub fn as_u32(message:&str)->(u32){
println!("{}",message);
let mut input = String::new();
std::io::stdin().read_line(&mut input).expect("Input Failed");
let integer: u32 = input.trim().parse().unwrap();
integer
}

#[doc="created function to reuse and reduce LOC for f64 input."]
#[allow(dead_code)]
pub fn as_f64(message:&str)->(f64){
#[allow(dead_code)]
println!("{}",message);
let mut input = String::new();
std::io::stdin().read_line(&mut input).expect("Input Failed");
let integer: f64 = input.trim().parse().unwrap();
integer
}

#[doc="created function to reuse and reduce LOC for i64 input."]
#[allow(dead_code)]
pub fn as_i64(message:&str)->(i64){
println!("{}",message);
let mut input = String::new();
std::io::stdin().read_line(&mut input).expect("Input Failed");
let integer: i64 = input.trim().parse().unwrap();
integer
}

#[doc="created function to reuse and reduce LOC for u64 input."]
#[allow(dead_code)]
pub fn as_u64(message:&str)->(u64){
println!("{}",message);
let mut input = String::new();
std::io::stdin().read_line(&mut input).expect("Input Failed");
let integer: u64 = input.trim().parse().unwrap();
integer
}

#[doc="created function to reuse and reduce LOC for u16 input."]
#[allow(dead_code)]
pub fn as_i128(message:&str)->(i128){
println!("{}",message);
let mut input = String::new();
std::io::stdin().read_line(&mut input).expect("Input Failed");
let integer: i128 = input.trim().parse().unwrap();
integer
}

#[doc="created function to reuse and reduce LOC for u16 input."]
#[allow(dead_code)]
pub fn as_u128(message:&str)->(u128){
println!("{}",message);
let mut input = String::new();
std::io::stdin().read_line(&mut input).expect("Input Failed");
let integer: u128 = input.trim().parse().unwrap();
integer
}