Rust Lessons

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 
// Included/Imported (1) Modules  use std::env; use std::fs::File; use std::io::{Read, Write}; use std::process; const BUF_SIZE: usize = 256; // Constant (2): `BUF_SIZE`. Type: `usize`. // Defines fixed size of data buffer. fn main() { // Variable (3): `args`. Type: `Vec<String>`. Stores command // line args. Purpose is processing file copies // based on input args. let args: Vec<String> = env::args().collect(); // Control Flow (4): Conditional `if`. Checks if number // of command line args is exactly 3 (program name, // input file path and output file path) // Edge Case: `args.len()` too short, too long. if args.len() != 3 { // Operation (5): Prints usage info on stderr. // Implies error in number of args. eprintln!("Usage: {} file1 file2", args[0]); // Operation (6): Terminate program with failure // code. Indicates incorrect usage. process::exit(1); } // Variable (7): `in_file`. Type: `File`. Represents // input file object which is opened for reading. // Purpose is to read contents from it. // Sub unit : File handle. // Result: `File`, or `Err`. let mut in_file = match File::open(&args[1]) { // Control Flow (8): `match` expression on `Result`. // `Ok` path opens file, `Err` handles open failure. Ok(file) => file, // Control Flow (9): Error handler for file open. Err(err) => { // Operation (10): Prints error details of open on // stderr. Indicates file access failure. eprintln!("{}: {}", args[1], err); // Operation (11): Exits program due to open // failure. Input file is critical. process::exit(2); } }; // Variable (12): `out_file`. Type: `File`. Represents // output file object which is opened for writing. // Purpose is to write contents to it. // Sub unit : File handle. // Result: `File`, or `Err`. let mut out_file = match File::create(&args[2]) { // Control Flow (13): `match` expression on `Result`. // `Ok` creates file, `Err` handles create failure. Ok(file) => file, // Control Flow (14): Error handler for file create. Err(err) => { // Operation (15): Prints error details of file // create on stderr. Indicates file creation fail. eprintln!("{}: {}", args[2], err); // Operation (16): Exits program due to create // failure. Output file is critical. process::exit(3); } }; // Variable (17): `buffer`. Type: `[u8; BUF_SIZE]`. // Fixed size buffer to store data read from input // file. Data unit: fixed size array of bytes. // Size: BUF_SIZE bytes. let mut buffer = [0u8; BUF_SIZE]; // Control Flow (18): Infinite `loop`. Reads data from input file, // writes data to output file, terminates when // end-of-file is reached or error occurs loop { // Variable (19): `bytes_in`. Type: `usize`. Stores // number of bytes read from the file in current iteration. // Domain: Non-negative integers <= BUF_SIZE. // Range: 0 to BUF_SIZE. let bytes_in = match in_file.read(&mut buffer) { // Control Flow (20): `match` for result from read. // `Ok` provides number of bytes read. Ok(n) => n, // Control Flow (21): Error handler for read errors. Err(err) => { // Operation (22): Prints file read error to stderr. // Indicates low level file system issues. eprintln!("Error reading file: {}", err); // Operation (23): Terminates program on read error. // Input file data is necessary. process::exit(4); } }; // Control Flow (24): Checks for end-of-file condition. // Checks if bytes read in last read were zero. if bytes_in == 0 { // Operation (25): Breaks infinite loop upon EOF. // Terminates read write cycle. break; } // Control Flow (26): Conditional `if let Err()`. // Writes bytes read to output file, checks for error if let Err(err) = out_file.write_all(&buffer[..bytes_in]) { // Operation (27): Print error message on stderr. // Indicates critical failure in file write. eprintln!("Fatal write error: {}", err); // Operation (28): Terminate program upon write fail // Output file write is necessary. process::exit(5); } } }