dukantic/Oeufman
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

work

Browse Source
This commit is contained in:
Dukantic
2025-04-09 12:10:50 +02:00
parent d286ef66c1
commit e5614a8f2a
1 changed files with 60 additions and 88 deletions
Download Patch File Download Diff File Expand all files Collapse all files

148
src/main.rs
View File

@@ -13,21 +13,22 @@ use node::{Node, create_tree, read_tree, tree_to_map, tree_to_string};
fn main() -> std::io::Result<()> { fn main() -> std::io::Result<()> {
let args: Vec<String> = env::args().collect(); let args: Vec<String> = env::args().collect();
println!("Arguments passés au programme :");
for (index, arg) in args.iter().enumerate() {
println!("Argument {}: {}", index, arg);
}
let request = args.get(1).map(|s| s.to_string()); let request = args.get(1).map(|s| s.to_string());
match request { match request {
Some(r) => { Some(r) => {
if r == "compress" || r == "c" { if r == "--compress" || r == "-c" {
let file_name = args.get(2).map(|s| s.to_string()); let file_name = args.get(2).map(|s| s.to_string());
let file_to_un = args.get(3).map(|s| s.to_string());
match file_name { match file_name {
Some(f) => { Some(f) => {
let mut to_compress = File::open(&f)?; let mut to_compress = File::open(&f)?;
let mut after_compression = File::create(f + ".oeuf")?; let mut after_compression: File;
if let Some(str) = file_to_un {
after_compression = File::create(str)?;
} else {
after_compression = File::create(f + ".oeuf")?;
}
let map = get_map_file(&to_compress)?; let map = get_map_file(&to_compress)?;
let nodes = nodes_at_vec(map); let nodes = nodes_at_vec(map);
let mut tree = create_tree(nodes); let mut tree = create_tree(nodes);
@@ -35,16 +36,14 @@ fn main() -> std::io::Result<()> {
let binary = string_to_binary(&str_bin); let binary = string_to_binary(&str_bin);
let len_tree: u32 = str_bin.len() as u32; let len_tree: u32 = str_bin.len() as u32;
let string: String = chars.iter().collect(); let string: String = chars.iter().collect();
after_compression.write_all( after_compression
&(len_tree + (string.as_bytes().len() as u32) * 8).to_be_bytes(), .write_all(&(len_tree + (string.len() as u32) * 8).to_be_bytes())?;
)?;
after_compression.write_all(&len_tree.to_be_bytes())?; after_compression.write_all(&len_tree.to_be_bytes())?;
after_compression.write_all(&binary)?; after_compression.write_all(&binary)?;
after_compression.write_all(string.as_bytes())?; after_compression.write_all(string.as_bytes())?;
to_compress.seek(SeekFrom::Start(0))?; to_compress.seek(SeekFrom::Start(0))?;
let mut map = tree_to_map(&mut tree, true); let map = tree_to_map(&mut tree, true);
let mut trad = translate_char_bin(&mut to_compress, map); let trad = translate_char_bin(&mut to_compress, map);
//eprintln!("trad = {:?}", trad);
let trad_bin = string_to_binary(&trad); let trad_bin = string_to_binary(&trad);
let len_body = trad.len() as u32; let len_body = trad.len() as u32;
after_compression.write_all(&len_body.to_be_bytes())?; after_compression.write_all(&len_body.to_be_bytes())?;
@@ -55,38 +54,39 @@ fn main() -> std::io::Result<()> {
display_options(); display_options();
} }
} }
} else if r == "print" || r == "p" { } else if r == "--print" || r == "-p" {
let file_name = args.get(2).map(|s| s.to_string()); let file_name = args.get(2).map(|s| s.to_string());
match file_name { match file_name {
Some(f) => { Some(f) => {
let mut to_print = File::open(f)?; let mut to_print = File::open(f)?;
let mut buffer = [0u8; 4]; let untranslate = string_translate(&mut to_print);
to_print.read_exact(&mut buffer)?; eprintln!("untranslate = {}", untranslate);
let mut len_head = u32::from_be_bytes(buffer);
to_print.read_exact(&mut buffer)?;
let len_tree = u32::from_be_bytes(buffer);
//eprintln!("len_head = {:?}", len_head);
//eprintln!("len_tree = {:?}", len_tree);
let len_chars = len_head - len_tree;
let tree_bin = read_n_bytes(&mut to_print, len_tree);
let tree_str = binary_to_string(tree_bin, len_tree);
//eprintln!("tree_str = {:?}", tree_str);
let chars_bin = read_n_bytes(&mut to_print, len_chars);
let chars_str = String::from_utf8(chars_bin).unwrap();
let mut root = read_tree(&tree_str, &chars_str.chars().collect());
let txt = tree_to_string(&mut root);
to_print.read_exact(&mut buffer)?;
let len_body = u32::from_be_bytes(buffer);
let untranslate = translate_bin_char(&mut to_print, root, len_body);
eprintln!("untranslate = {:?}", untranslate);
} }
None => { None => {
println!("No file name!"); println!("No file name!");
display_options(); display_options();
} }
} }
} else if r == "--uncompress" || r == "-u" {
let file_name = args.get(2).map(|s| s.to_string());
let file_to_un = args.get(3).map(|s| s.to_string());
match file_name {
Some(f) => {
let mut to_uncomp = File::open(&f)?;
let mut uncomp: File;
if let Some(str) = file_to_un {
uncomp = File::create(str)?;
} else {
uncomp = File::create(f + ".txt")?;
}
let txt = string_translate(&mut to_uncomp);
uncomp.write_all(txt.as_bytes())?;
}
None => {
println!("No File name !");
display_options();
}
}
} }
} }
None => { None => {
@@ -95,56 +95,6 @@ fn main() -> std::io::Result<()> {
} }
} }
//let file = File::open("test.txt")?;
//let mut file2 = File::open("fo.txt")?;
//let map = get_map_file(file).expect("Failed to load!");
//let vec = nodes_at_vec(map);
//let mut root = node::create_tree(vec);
//eprintln!("root.n = {:#?}", root.l.unwrap().n);
//let txt = tree_to_string(&mut root);
//eprintln!("txt = {:?}", txt);
/*
let mut root2 = read_tree(&txt.0, &txt.1);
eprintln!(
"root2.l.unwrap().l.unwrap().val = {:?}",
root2.l.unwrap().l.unwrap().val
);
*/
/*
let binary = "101100001";
let mut v = string_to_binary(binary);
let length = (binary.len() % 8) as u8;
//eprintln!("v = {:?}", v);
let len_bytes = length.to_be_bytes();
eprintln!("v = {:?}", v);
eprintln!("len = {:?}", len_bytes);
println!("101100001");
file2.write_all(&len_bytes)?;
file2.write_all(&v)?;*/
/*
let mut buffer = [0u8; 1];
file2.read_exact(&mut buffer)?;
eprintln!("buffer = {:?}", buffer);
let len = u8::from_be_bytes(buffer);
eprintln!("len = {:?}", len);
let mut read = Vec::new();
file2.read_to_end(&mut read)?;
eprintln!("read = {:?}", read);
//let current = read[4..].to_vec();
let string = binary_to_string(read, len);
eprintln!("string = {:?}", string);
*/
//eprintln!("v = {:#?}", v);
//eprintln!("buffer = {:#?}", buffer);
//writeln!(file2, "{}", tes;t)?;
//file2.write_all(&test.to_be_bytes())?;
//file2.write_all(&[*key as u8])?;
//writeln!(file2, ":{}", value)?;
//file2.write_all(&value.to_be_bytes())?;
Ok(()) Ok(())
} }
@@ -165,6 +115,28 @@ fn get_map_file(mut file: &File) -> Result<HashMap<char, i32>, std::io::Error> {
Ok(hashmap) Ok(hashmap)
} }
fn string_translate(file: &mut File) -> String {
let mut buffer = [0u8; 4];
let _ = file.read_exact(&mut buffer);
let len_head = u32::from_be_bytes(buffer);
let _ = file.read_exact(&mut buffer);
let len_tree = u32::from_be_bytes(buffer);
//eprintln!("len_head = {:?}", len_head);
//eprintln!("len_tree = {:?}", len_tree);
let len_chars = len_head - len_tree;
let tree_bin = read_n_bytes(file, len_tree);
let tree_str = binary_to_string(tree_bin, len_tree);
//eprintln!("tree_str = {:?}", tree_str);
let chars_bin = read_n_bytes(file, len_chars);
let chars_str = String::from_utf8(chars_bin).unwrap();
let root = read_tree(&tree_str, &chars_str.chars().collect());
let _ = file.read_exact(&mut buffer);
let len_body = u32::from_be_bytes(buffer);
translate_bin_char(file, root, len_body)
}
fn nodes_at_vec(map: HashMap<char, i32>) -> Vec<Node> { fn nodes_at_vec(map: HashMap<char, i32>) -> Vec<Node> {
let mut nodes = Vec::new(); let mut nodes = Vec::new();
@@ -201,7 +173,7 @@ fn translate_char_bin(file: &mut File, map: HashMap<String, String>) -> String {
let mut txt = String::new(); let mut txt = String::new();
let mut translate = String::new(); let mut translate = String::new();
file.read_to_string(&mut txt); let _ = file.read_to_string(&mut txt);
for c in txt.chars() { for c in txt.chars() {
if let Some(code) = map.get(&c.to_string()) { if let Some(code) = map.get(&c.to_string()) {
translate.push_str(code); translate.push_str(code);
@@ -215,8 +187,8 @@ fn translate_bin_char(file: &mut File, root: Node, len: u32) -> String {
let mut translate = String::new(); let mut translate = String::new();
let mut current = &root; let mut current = &root;
file.read_to_end(&mut txt); let _ = file.read_to_end(&mut txt);
let mut txt_str = binary_to_string(txt, len); let txt_str = binary_to_string(txt, len);
for b in txt_str.chars() { for b in txt_str.chars() {
match b { match b {
'1' => { '1' => {