File I/O

This page is under construction. Please come back later.

FileIO1.rs

/******************************************************************************
 * This program simply copies a file to the console character by
 * character like the Unix 'cat' program.
 * 
 * Copyright © 2020 Richard Lesh.  All rights reserved.
 *****************************************************************************/

#![allow(dead_code)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#[macro_use]
mod utils;
use std::env;
use std::fs::{File};
use std::io::{BufReader, self};
use std::process::{self};

fn read_text_file(filespec:&str) -> Result<(), utils::CustomError> {
	let mut ifh:BufReader<File> = BufReader::new(File::open(filespec)?);
	let mut c:Option<u32>;
	c = utils::getcodepoint(&mut ifh);
	while c != None {
		utils::putcodepoint(&mut io::stdout(), c.unwrap());
		c = utils::getcodepoint(&mut ifh);
	}
	return Ok(());
}

fn main() {
	let args: Vec<String> = env::args().collect();
	if args.len() != 2 {
		println!("Syntax: FileIO1 {{filename}}");
		process::exit(1);
	}
	let filespec:String = args[1].to_string();
	match (|| -> Result<(), utils::CustomError>{
		read_text_file(&filespec)?;
		return Ok(());
	})() {
		Ok(()) => {},
		Err(ex) => {
			match ex {
				utils::CustomError::IOError(ex) => {
					println!("Error: {}", format!("{}", ex));
				}
				_ => {
					println!("Unexpected File Read Error");
				}
			}
		}
	};
}

FileIO2.rs

/******************************************************************************
 * This program simply copies a file to the console line by line.
 * 
 * Copyright © 2020 Richard Lesh.  All rights reserved.
 *****************************************************************************/

#![allow(dead_code)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#[macro_use]
mod utils;
use std::env;
use std::fs::{File};
use std::io::{BufReader, BufRead};
use std::process::{self};

fn read_text_file(filespec:&str) -> Result<(), utils::CustomError> {
	let mut ifh:BufReader<File> = utils::open_file_read(filespec)?;
	let mut line:String = String::from("");
	while ifh.read_line(&mut line).unwrap_or(0) != 0 {
		line = String::from(line.trim_end().to_string());
		println!("{}", line);
		line.clear();
	}
	return Ok(());
}

fn main() {
	let args: Vec<String> = env::args().collect();
	if args.len() != 2 {
		println!("Syntax: FileIO2 {{filename}}");
		process::exit(1);
	}
	let filespec:String = args[1].to_string();
	match (|| -> Result<(), utils::CustomError>{
		read_text_file(&filespec)?;
		return Ok(());
	})() {
		Ok(()) => {},
		Err(ex) => {
			match ex {
				utils::CustomError::IOError(ex) => {
					println!("Error: {}", format!("{}", ex));
				}
				_ => {
					println!("Unexpected File Read Error");
				}
			}
		}
	};
}

FileIO3.rs

/******************************************************************************
 * This program reads bytes from a file and prints them in hexadecimal format.
 * 
 * Copyright © 2021 Richard Lesh.  All rights reserved.
 *****************************************************************************/

#![allow(dead_code)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#[macro_use]
mod utils;
use std::env;
use std::fs::{File};
use std::io::{BufReader};
use std::process::{self};

fn read_binary_file(filespec:&str) -> Result<(), utils::CustomError> {
	let mut ifh:BufReader<File> = utils::open_file_read(filespec)?;
	let mut c:Option<u8>;
	let mut count:isize = 0;
	c = utils::getbyte(&mut ifh);
	while c != None {
		print!("{0:02x} ", c.unwrap());
		count += 1;
		if count % 16 == 0 {
			println!("");
		}
		c = utils::getbyte(&mut ifh);
	}
	if count % 16 != 0 {
		println!("");
	}
	return Ok(());
}

fn main() {
	let args: Vec<String> = env::args().collect();
	if args.len() != 2 {
		println!("Syntax: FileIO3 {{filename}}");
		process::exit(1);
	}
	let filespec:String = args[1].to_string();
	match (|| -> Result<(), utils::CustomError>{
		read_binary_file(&filespec)?;
		return Ok(());
	})() {
		Ok(()) => {},
		Err(ex) => {
			match ex {
				utils::CustomError::IOError(ex) => {
					println!("Error: {}", format!("{}", ex));
				}
				_ => {
					println!("Unexpected File Read Error");
				}
			}
		}
	};
}

FileIO4.rs

/******************************************************************************
 * This program simply writes characters from the alphabet to a file.
 * 
 * Copyright © 2020 Richard Lesh.  All rights reserved.
 *****************************************************************************/

#![allow(dead_code)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#[macro_use]
mod utils;
use std::env;
use std::fs::{File};
use std::io::{BufWriter, Write};
use std::process::{self};

fn write_text_file(filespec:&str) -> Result<(), utils::CustomError> {
	let mut ofh:BufWriter<File> = BufWriter::new(File::create(filespec)?);
// Latin alphabet
	{
		let mut c:u32 = 0x41;
		while c <= 0x5A {
			utils::put_codepoint(&mut ofh, c);
			c += 1;
		}
	}
	write!(ofh, "{}", '\n')?;
// Greek alphabet
	{
		let mut c:u32 = 0x391;
		while c <= 0x3A9 {
			utils::put_codepoint(&mut ofh, c);
			c += 1;
		}
	}
	write!(ofh, "{}", '\n')?;
// Cyrillic alphabet
	{
		let mut c:u32 = 0x410;
		while c <= 0x42F {
			utils::put_codepoint(&mut ofh, c);
			c += 1;
		}
	}
	write!(ofh, "{}", '\n')?;
// Katakana alphabet
	{
		let mut c:u32 = 0x30A0;
		while c <= 0x30FF {
			utils::put_codepoint(&mut ofh, c);
			c += 1;
		}
	}
	write!(ofh, "{}", '\n')?;
	ofh.flush()?;
	return Ok(());
}

fn main() {
	let args: Vec<String> = env::args().collect();
	if args.len() != 2 {
		println!("Syntax: FileIO4 {{filename}}");
		process::exit(1);
	}
	let filespec:String = args[1].to_string();
	match (|| -> Result<(), utils::CustomError>{
		write_text_file(&filespec)?;
		return Ok(());
	})() {
		Ok(()) => {},
		Err(ex) => {
			match ex {
				utils::CustomError::IOError(ex) => {
					println!("Error: {}", format!("{}", ex));
				}
				_ => {
					println!("Unexpected File Read Error");
				}
			}
		}
	};
}

FileIO5.rs

/******************************************************************************
 * This program simply writes lines with the alphabet to a file.
 * 
 * Copyright © 2020 Richard Lesh.  All rights reserved.
 *****************************************************************************/

#![allow(dead_code)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#[macro_use]
mod utils;
use std::process::{self};

fn write_text_file(filespec:&str) -> Result<(), utils::CustomError> {
	printLine("ABCDEFGHIJKLMNOPQRSTUVWXYZ",ofh.unwrap());
	printLine("ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩ",ofh.unwrap());
	printLine("АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ",ofh.unwrap());
	printLine("゠ァアィイゥウェエォオカガキギクグケゲコゴサザシジスズセゼソゾタ",ofh.unwrap());
	printLine("ダチヂッツヅテデトドナニヌネノハバパヒビピフブプヘベペホボポマミ",ofh.unwrap());
	printLine("ムメモャヤュユョヨラリルレロヮワヰヱヲンヴヵヶヷヸヹヺ・ーヽヾヿ",ofh.unwrap());
	return Ok(());
}

fn main() {
	if args.len() != 2 {
		println!("Syntax: FileIO5 {{filename}}");
		process::exit(1);
	}
	let filespec:String = args[1].to_string();
	match (|| -> Result<(), utils::CustomError>{
		write_text_file(&filespec)?;
		return Ok(());
	})() {
		Ok(()) => {},
		Err(ex) => {
			match ex {
				utils::CustomError::IOError(ex) => {
					println!("Error: {}", format!("{}", ex));
				}
				_ => {
					println!("Unexpected File Write Error");
				}
			}
		}
	};
}

FileIO6.rs

/******************************************************************************
 * This program simply writes the bytes 0 - 256 to a binary file.
 * 
 * Copyright © 2021 Richard Lesh.  All rights reserved.
 *****************************************************************************/

#![allow(dead_code)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#[macro_use]
mod utils;
use std::env;
use std::process;

fn write_binary_file(filespec:&str) -> Result<(), utils::CustomError> {
	{
		let mut b:isize = 0;
		while b <= 255 {
			ofh.write(&[b])?;
			b += 1;
		}
	}
	return Ok(());
}

fn main() {
	let args: Vec<String> = env::args().collect();
	if args.len() != 2 {
		println!("Syntax: FileIO6 {{filename}}");
		process::exit(1);
	}
	let mut filespec:String = args[1];
	match (|| -> Result<(), utils::CustomError>{
		write_binary_file(&filespec)?;
		return Ok(());
	})() {
		Ok(()) => {},
		Err(ex) => {
			match ex {
				utils::CustomError::IOError(ex) => {
					println!("Error: {}", format!("{}", ex));
				}
			}
		}
	};
}

FileIO7.rs

/******************************************************************************
 * This program simply copies one file to another, character by
 * character like the Unix 'cat' program.
 * 
 * Copyright © 2020 Richard Lesh.  All rights reserved.
 *****************************************************************************/

#![allow(dead_code)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#[macro_use]
mod utils;
use std::process;

fn copy_text_file(from_filespec:&str, to_filespec:&str) -> Result<(), utils::CustomError> {
	let mut c:u32;
	while getcodepoint(c,ifh) {
		putcodepoint(c,ofh);
	}
	return Ok(());
}

fn main() {
	if args.len() != 3 {
		println!("Syntax: FileIO7 {{fromFilespec}} {{toFilespec}}");
		process::exit(1);
	}
	let mut from_filespec:String = args[1];
	let mut to_filespec:String = args[2];
	match (|| -> Result<(), utils::CustomError>{
		copy_text_file(&from_filespec, &to_filespec)?;
		return Ok(());
	})() {
		Ok(()) => {},
		Err(ex) => {
			match ex {
				utils::CustomError::IOError(ex) => {
					println!("Error: {}", format!("{}", ex));
				}
			}
		}
	};
}

FileIO8.rs

/******************************************************************************
 * This program simply copies one file to another, line by line.
 * 
 * Copyright © 2020 Richard Lesh.  All rights reserved.
 *****************************************************************************/

#![allow(dead_code)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#[macro_use]
mod utils;
use std::process;

fn copy_text_file(from_filespec:&str, to_filespec:&str) -> Result<(), utils::CustomError> {
	let mut line:String;
	while ifh.read_line(&mut line).expect("Failed to read line") {
		printLine(line,ofh);
	}
	return Ok(());
}

fn main() {
	if args.len() != 3 {
		println!("Syntax: FileIO8 {{fromFilespec}} {{toFilespec}}");
		process::exit(1);
	}
	let mut from_filespec:String = args[1];
	let mut to_filespec:String = args[2];
	match (|| -> Result<(), utils::CustomError>{
		copy_text_file(&from_filespec, &to_filespec)?;
		return Ok(());
	})() {
		Ok(()) => {},
		Err(ex) => {
			match ex {
				utils::CustomError::IOError(ex) => {
					println!("Error: {}", format!("{}", ex));
				}
			}
		}
	};
}

FileIO9.rs

/******************************************************************************
 * This program reads bytes from a binary file and copies them to another file.
 * 
 * Copyright © 2021 Richard Lesh.  All rights reserved.
 *****************************************************************************/

#![allow(dead_code)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#[macro_use]
mod utils;
use std::env;
use std::io::Read;
use std::process;

fn copy_binary_file(from_filespec:&str, to_filespec:&str) -> Result<(), utils::CustomError> {
	let mut c:u8;
	while (c = utils::getbyte(&mut ifh)) != -1 {
		ofh.write(&[c])?;
	}
	return Ok(());
}

fn main() {
	let args: Vec<String> = env::args().collect();
	if args.len() != 3 {
		println!("Syntax: FileIO9 {{fromFilespec}} {{toFilespec}}");
		process::exit(1);
	}
	let mut from_filespec:String = args[1];
	let mut to_filespec:String = args[2];
	match (|| -> Result<(), utils::CustomError>{
		copy_binary_file(&from_filespec, &to_filespec)?;
		return Ok(());
	})() {
		Ok(()) => {},
		Err(ex) => {
			match ex {
				utils::CustomError::IOError(ex) => {
					println!("Error: {}", format!("{}", ex));
				}
			}
		}
	};
}

Questions

• {{Who's on first?}}
• {{Who's on second?}}
• {{Who's on third?}}

Projects

More ★'s indicate higher difficulty level.

• Base64 Decoding
• Base64 Encoding
• ChaCha20 Cipher
• Number of Primes
• One-Way Hash
• Palindrome Search
• Spell Checker
• XOR Cipher

References

• [[Rust Language Reference]]
• [[Rust Compiler]]