Day 21: It's Blitzen again

“Why is the sleigh autopilot slower than a reindeer in quicksand? JINGLESTACK is down, and the temp directory is 800 terabytes!”

Blitzen spins around in his chair, looking guilty. “It’s… fine! Just a minor bug in my Rust code.”

Bernard, the lead elf, cuts in, holding a clipboard. “A bug? Every file in the temp directory is creating three more when dropped. It’s a recursive explosion!”

Santa’s eyes narrow at Blitzen. “Recursive explosion? You’ve turned my servers into a snowball fight gone wrong! Fix it now, or I’ll make you clean every one of those files manually!”

Blitzen gulps, this is not his first time making Santa angry, cracking his knuckles. “On it! Uh, any chance we can blame the interns?”

Santa points a candy cane at him. “One more excuse, and you’re off sleigh duty for good!”

Your Mission

The previous code Blitzen has written was supposed to create temporary files, but they were permanent.

You need to write a struct TempFile that is temporary and it will delete itself when out of scope.

Requirements

The TempFile struct should have the following fields:

file_path - a PathBuf that represents the path of the file.
file - a File that represents the file.

The TempFile struct should have the following methods:

new - a method that creates a file in the /tmp directory with a random name.
write - a method that writes bytes &[u8] to the file.
read_to_string - a method that reads the file and returns a String.

Hints

If you’re unsure where to start, take a look at these tips:

Click to reveal hints!

Use std::env::temp_dir() to get the temporary directory.
Use std::fs::File to create an empty file. e.g. File::create(&file_path).

To open an already created file, use OpenOptions::new() and open(). e.g. For reading:

  use std::fs::OpenOptions;
 
  pub fn read_to_string(&self) -> Result<String, std::io::Error> {
      let mut file = OpenOptions::new().read(true).open(&self.file_path)?;
      let mut buffer = String::new();
      file.read_to_string(&mut buffer)?;
      Ok(buffer)
  }

For writing, you can use OpenOptions::new().write(true).open(&self.file_path)?.

Editor not available on Mobile!

In order to solve the challenge, please visit this page on a desktop computer.

Solutions

zeitnut

9 hours ago

4.02ms

88.02kb

use std::path::PathBuf;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::fs::File;
use std::fs;
use std::io::Write;
pub struct TempFile {
    file_path: PathBuf,
    file: fs::File,
}
// Simplest way to get a unique file name is to use a counter, but it's not really "random".
// Unable to use crates like rand or uuid in this exercise.
// Could base the filename on SystemTime, but that's not monotonic.
// Actually, the std lib provides Instant, which is monotonic - could convert that to a Duration in nanos.
// Instant::now().elapsed().as_nanos().to_string()
static TEMP_FILE_COUNT: AtomicUsize = AtomicUsize::new(0);
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        // Improvement after checking hints - don't assume temp dir is /tmp (as that's platform-specific)
        // and don't assume directory separator is forward slash - use join() method instead.
        let file_path = std::env::temp_dir().join(format!(
            "TempFile{}.tmp",
            TEMP_FILE_COUNT.fetch_add(1, Ordering::SeqCst)
        ));
        fs::File::create(&file_path).map(|file| Self {
            file_path, file
        })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        // If the file is not empty, this overwrites the contents.
        // Unclear if that's what we want - maybe it should append.
        // No point using fs::write(&self.file_path, data) here as the file is already open for writing (File::create does that).
        self.file.write_all(data)
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        fs::read_to_string(&self.file_path)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        fs::remove_file(&self.file_path).unwrap_or_else(|e| eprintln!("Error deleting {} - {}", self.file_path.display(), e));
    }
}

hoslo

6 days ago

4.35ms

87.95kb

use std::{
    fs::{self, File, OpenOptions},
    io::{Read, Seek, SeekFrom, Write},
    path::PathBuf,
    time::{self, Instant, UNIX_EPOCH},
};
pub struct TempFile {
    pub file_path: std::path::PathBuf,
    pub file: File,
}
impl Drop for TempFile {
    fn drop(&mut self) {
        _ = fs::remove_file(&self.file_path);
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        // Your code here...
        let mut path = std::env::temp_dir();
        path.push(format!(
            "tmp_{}",
            time::SystemTime::now()
                .duration_since(UNIX_EPOCH)
                .unwrap_or(Instant::now().elapsed())
                .as_nanos()
        ));
        Ok(Self {
            file: OpenOptions::new()
                .create(true)
                .write(true)
                .read(true)
                .truncate(true)
                .open(&path)?,
            file_path: path,
        })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        // Your code here...
        self.file.write_all(data)
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        // Your code here...
        self.file.seek(SeekFrom::Start(0))?;
        let mut s = String::new();
        self.file.read_to_string(&mut s)?;
        Ok(s)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}
fn main() {}

DFC-Siege

7 days ago

5.02ms

87.95kb

use std::fs;
use std::fs::{File, OpenOptions};
use std::io::{Read, Seek, SeekFrom, Write};
use std::path::PathBuf;
use std::time::{self, Instant, UNIX_EPOCH};
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl Drop for TempFile {
    fn drop(&mut self) {
        _ = fs::remove_file(&self.file_path);
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        // Your code here...
        let mut path = std::env::temp_dir();
        path.push(format!(
            "tmp_{}",
            time::SystemTime::now()
                .duration_since(UNIX_EPOCH)
                .unwrap_or(Instant::now().elapsed())
                .as_nanos()
        ));
        Ok(Self {
            file: OpenOptions::new()
                .create(true)
                .write(true)
                .read(true)
                .truncate(true)
                .open(&path)?,
            file_path: path,
        })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        // Your code here...
        self.file.write_all(data)?;
        Ok(())
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        // Your code here...
        self.file.seek(SeekFrom::Start(0))?;
        let mut result = String::new();
        self.file.read_to_string(&mut result)?;
        Ok(result)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}

yuiidev

10 days ago

6.36ms

87.39kb

use std::env::temp_dir;
use std::fs::{remove_file, File, OpenOptions};
use std::io::{Read, Write};
use std::path::PathBuf;
use std::time::{Instant};
pub struct TempFile {
    pub file_path: PathBuf,
    pub file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let file_path = temp_dir().join(format!("tmp_{}", Instant::now().elapsed().as_nanos().to_string()));
        let file = File::create(&file_path)?;
        Ok(TempFile {file_path, file})
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        self.file.write_all(data)
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        let mut file = OpenOptions::new().read(true).open(&self.file_path)?;
        let mut buffer = String::new();
        file.read_to_string(&mut buffer)?;
        Ok(buffer)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        _ = remove_file(&self.file_path)
    }
}

diucicd

15 days ago

5.23ms

87.97kb

use std::{
    fs::{File, OpenOptions},
    io::{Read, Write},
    path::PathBuf,
    time::{Instant, SystemTime, UNIX_EPOCH},
};
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let mut file_path = std::env::temp_dir();
        let curr_time = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap_or(Instant::now().elapsed())
            .as_nanos();
        let tmp_file_name = format!("temp_file_{}.txt", curr_time);
        file_path.push(tmp_file_name);
        let file = File::create(&file_path)?;
        Ok(Self { file_path, file })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        self.file.write_all(data)
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        let mut file = OpenOptions::new().read(true).open(&self.file_path)?;
        let mut buffer = String::new();
        file.read_to_string(&mut buffer)?;
        Ok(buffer)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        _ = std::fs::remove_file(&self.file_path);
    }
}

Pumkko

18 days ago

7.42ms

87.95kb

use std::{
    fs::{File, OpenOptions},
    io::{Read, Write},
    path::PathBuf,
    time::{Instant, SystemTime, UNIX_EPOCH},
};
pub struct TempFile {
    pub file_path: PathBuf,
    pub file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        // Your code here...
        let mut tmp = std::env::temp_dir();
        let curr_time = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap_or(Instant::now().elapsed())
            .as_nanos();
        let file_name = format!("tmp{curr_time}");
        tmp.push(file_name);
        let file = File::create(&tmp)?;
        Ok(Self {
            file_path: tmp,
            file,
        })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        // Your code here...
        self.file.write_all(data)
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        // Your code here...
        let mut file = OpenOptions::new().read(true).open(&self.file_path)?;
        let mut result = String::new();
        file.read_to_string(&mut result)?;
        Ok(result)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        _ = std::fs::remove_file(&self.file_path);
    }
}

Erik Hollembeak

futureperfect

21 days ago

5.61ms

87.96kb

use std::path::PathBuf;
use std::fs::File;
use std::io::{Read, Write};
use std::time::SystemTime;
use std::time::UNIX_EPOCH;
use std::time::Instant;
use std::fs::remove_file;
use std::fs::OpenOptions;
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let mut file_path = std::env::temp_dir();
        let curr_time = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap_or(Instant::now().elapsed())
            .as_nanos();
        let file_name = format!("tmp{curr_time}.txt");
        file_path.push(file_name);
        let file = File::create(&file_path)?;
        Ok(TempFile {
            file_path: file_path,
            file: file,
        })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        self.file.write_all(data)
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        // Your code here...
        let mut file = OpenOptions::new().read(true).open(&self.file_path)?;
        let mut result = String::new();
        file.read_to_string(&mut result)?;
        Ok(result)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        _ = remove_file(&self.file_path);
    }
}

Erik Hollembeak

futureperfect

21 days ago

4.30ms

87.94kb

use std::path::PathBuf;
use std::fs::File;
use std::io::{Read, Seek, Write};
use std::time::SystemTime;
use std::time::UNIX_EPOCH;
use std::fs::remove_file;
use std::fs::OpenOptions;
pub struct TempFile {
    pub file_path: PathBuf,
    pub file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
       let timestamp = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_nanos()
            .to_string();
        
        let mut file_path = std::env::temp_dir();
        file_path.push(timestamp);
        let file = File::create(&file_path)?;   
        Ok(TempFile {
            file_path,
            file,
        })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        self.file.write_all(data)
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        let mut file = OpenOptions::new()
            .read(true)
            .open(&self.file_path)?;
        let mut buffer = String::new();
        file.rewind()?;
        file.read_to_string(&mut buffer)?;
        Ok(buffer)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        _ = remove_file(&self.file_path);
    }
}

deo2407

a month ago

5.30ms

87.96kb

use std::{path::PathBuf, env};
use std::fs::{OpenOptions, File, remove_file};
use std::io::prelude::*;
use std::time::{SystemTime, UNIX_EPOCH, Instant};
pub struct TempFile {
    pub file_path: PathBuf,
    pub file: File, 
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        // Your code here...
        let mut dir = env::temp_dir();
        let curr_time = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap_or(Instant::now().elapsed())
            .as_nanos();
        let file_name = format!("tmp{curr_time}.txt");
        dir.push(file_name);
        let file = File::create(&dir)?;
        Ok(TempFile {
            file_path: dir,
            file: file
        })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        // Your code here...
        let mut file = OpenOptions::new()
            .write(true)
            .open(&self.file_path)?;
        
        file.write(data)?;
        Ok(())
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        // Your code here...
        let mut file = OpenOptions::new()
            .read(true)
            .open(&self.file_path)?;
        let mut buffer = String::new();
        file.read_to_string(&mut buffer)?;
        Ok(buffer)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let _ = remove_file(&self.file_path);
    }
}

David Phillips

Zantier

a month ago

7.33ms

87.95kb

use std::{
    env::temp_dir,
    fs::{remove_file, File, OpenOptions},
    io::{Read, Seek, Write},
    path::PathBuf,
    sync::Mutex,
};
static GLOBAL_COUNTER: Mutex<u32> = Mutex::new(0);
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        // Your code here...
        let mut counter = GLOBAL_COUNTER.lock().unwrap();
        let file_path = temp_dir().join(counter.to_string());
        *counter += 1;
        let file = OpenOptions::new()
            .read(true)
            .write(true)
            .create(true)
            .open(&file_path)?;
        Ok(Self {
            file_path,
            file,
        })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        // Your code here...
        self.file.write_all(data)
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        // Your code here...
        self.file.rewind()?;
        let mut buf = String::new();
        self.file.read_to_string(&mut buf)?;
        Ok(buf)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        _ = remove_file(&self.file_path);
    }
}

Viwaswat Raj Singh

viwaswatraj

a month ago

5.44ms

88.37kb

use std::path::PathBuf;
use std::fs::{self, File, OpenOptions};
use std::io::{Read, Write};
use std::time::{SystemTime, UNIX_EPOCH};
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        // Your code here...
        let timestamp = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_nanos()
            .to_string();
        
        let mut file_path = std::env::temp_dir();
        file_path.push(timestamp);
        let file = File::create(&file_path)?;   
        Ok(TempFile {
            file_path,
            file,
        })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        // Your code here...
        self.file.write_all(data)
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        // Your code here...
        let mut file = OpenOptions::new()
            .read(true)
            .open(&self.file_path)?;
        let mut buffer = String::new();
        file.read_to_string(&mut buffer)?;
        Ok(buffer)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        println!("Deleting temp file {:?}", self.file_path);
        if let Err(e) = fs::remove_file(&self.file_path) {
            eprintln!("Cannot delete temp file {:?}: {e}", self.file_path);
        }
    }
}

Khalifa

e1ec30

a month ago

5.35ms

87.54kb

use std::{
    fs::{File, OpenOptions, self},
    io::{Read, Write},
    path::PathBuf
};
use std::time::{SystemTime, UNIX_EPOCH};
pub struct TempFile {
    file_path: PathBuf,
    file: File
}
impl Drop for TempFile {
    fn drop(&mut self) {
        if let Err(e) = fs::remove_file(&self.file_path) {
            eprintln!("Could not delete file {}: {e}", &self.path().display())
        }
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        // Your code here...
        let timestamp = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_nanos()
            .to_string();
        let mut file_path = PathBuf::new();
        file_path.push(std::env::temp_dir());
        file_path.push(timestamp);
        let file = File::create(&file_path)?;
        
        Ok(TempFile {
            file_path,
            file
        })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        // Your code here...
        self.file.write_all(data)?;
        Ok(())
        
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        // Your code here...
        let mut file = OpenOptions::new().read(true).open(self.path())?;
        let mut buffer = String::new();
        file.read_to_string(&mut buffer)?;
        Ok(buffer)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}

Pedro Diaz

pdiaz

2 months ago

5.45ms

88.39kb

use std::env::temp_dir;
use std::fs::{File, OpenOptions, remove_file};
use std::io::{Read, Write};
use std::path::PathBuf;
use std::time::SystemTime;
pub struct TempFile {
    file_path: std::path::PathBuf,
    file: std::fs::File,
}
impl Drop for TempFile {
    fn drop(&mut self) {
        println!("Deleting temp file at: {:?}", self.file_path);
        remove_file(self.file_path.clone()).unwrap_or_else(|_| {
            println!("Failed to delete temp file at: {:?}", self.file_path);
        });
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        // Use a random name for the file using a std library function, use SystemTime for randomness
        let mut random = SystemTime::now()
            .duration_since(SystemTime::UNIX_EPOCH)
            .unwrap()
            .as_nanos() as u64;
        let base_path = temp_dir();
        while base_path.join(format!("tempfile_{}", random)).exists() {
            random += 1;
        }
        let file_path = base_path.join(format!("tempfile_{}", random));
        println!("Creating temp file at: {:?}", file_path);
        let file = OpenOptions::new()
            .create(true)
            .truncate(true)
            .write(true)
            .open(&file_path)?;
        Ok(TempFile { file_path, file })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        self.file.write_all(data)
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        let mut file = OpenOptions::new().read(true).open(&self.file_path)?;
        let mut buffer = String::new();
        file.read_to_string(&mut buffer)?;
        Ok(buffer)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}

SalazarTh

2 months ago

5.55ms

87.55kb

use std::fs::{OpenOptions, File};
use std::path::PathBuf;
use std::io::{ Write, Read };
use std::fs;
use std::time::{Duration, SystemTime};
pub struct TempFile {
    file_path: PathBuf,
    file: File
}
impl Drop for TempFile {
    fn drop(&mut self) {
        if let Err(_) = fs::remove_file(&self.file_path) {
             println!("Error while remove file after drop");   
        }
        println!("File droped");
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        // Your code here...
    //    let mut random_file_unix = File::open("/dev/urandom")?;
    //     let mut buff = vec!(0u8, 7);
    //     random_file_unix.read_exact(&mut buff)?;
        let time =  SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap().as_nanos();
       let tmp = std::env::temp_dir(); 
       let random_name = format!("temp_file_{}.tmp", time);
       let mut file_path = PathBuf::new();
       file_path.push(tmp);
       file_path.push("/");
       file_path.push(random_name); 
       let file = File::create(&file_path)?;
       Ok(
        Self {
            file,
            file_path
        }
       ) 
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        // Your code here...
        let mut file = OpenOptions::new().write(true).open(&self.file_path)?;
        file.write(data)?;
        Ok(())
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        // Your code here...
        let mut file = OpenOptions::new().read(true).open(&self.file_path)?;
        let mut buffer = String::new();
        file.read_to_string(&mut buffer)?;
        Ok(buffer)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}

huanderer

2 months ago

6.69ms

87.84kb

use std::path::PathBuf;
use std::{env, fs::{self, File, write, remove_file}};
use std::time::{SystemTime, UNIX_EPOCH};
//use std::io::Write; //there are two writes, this is the second one. 
//use randomizer::Randomizer; can't use this because i need to mod the dependencies and this
//website does not allow that. 
#[derive(Debug)]
pub struct TempFile {
    file_path: PathBuf,
    file: std::fs::File 
}
impl Drop for TempFile { //implementing trait
    fn drop(&mut self){
        if let Err(e) = std::fs::remove_file(&self.file_path) {
            eprintln!("Failed to remove temporary file: {}", e);
        }
        println!("Dropped temporary file: {:?}", self.file_path)
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let mut path = env::temp_dir();
        let filename_front = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap().as_nanos();
        path.push(format!("{}.txt", filename_front)); //idiomatic way to do it. 
        
        //let slash = "/"; //this would be messed up on windows. 
        //let filename_ext = ".txt"; 
        //let path = tmp_dir.display().to_string() + slash + &filename_front.to_string() + filename_ext;
        
        let file = File::create(path.clone());
        
        Ok(Self
        {
            file_path: path.into(),
            file: file?
        })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        std::fs::write(self.file_path.clone(), data)?; //dont use unwrap() - use a question mark to
                                                       //auto handle the errors. 
        Ok(())
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        let msg: String = fs::read_to_string(self.file_path.clone())?;
        Ok(msg)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}
pub fn main() {
    let temp = TempFile::new();
    println!("{:?}", temp);
    let array = [1,2,3,4,5];
    let written = temp.unwrap().write(&array);
    println!("{:?}", written);
}

huanderer

2 months ago

7.01ms

88.34kb

use std::path::PathBuf;
use std::{env, fs::{self, File, write, remove_file}};
use std::time::{SystemTime, UNIX_EPOCH};
//use std::io::Write; //there are two writes, this is the second one. 
//use randomizer::Randomizer; can't use this because i need to mod the dependencies and this
//website does not allow that. 
#[derive(Debug)]
pub struct TempFile {
    file_path: PathBuf,
    file: std::fs::File 
}
impl Drop for TempFile { //implementing trait
    fn drop(&mut self){
        if let Err(e) = std::fs::remove_file(&self.file_path) {
            eprintln!("Failed to remove temporary file: {}", e);
        }
        println!("Dropped temporary file: {:?}", self.file_path)
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let tmp_dir = env::temp_dir();
        let slash = "/";
        let filename_front = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap().as_nanos();
        let filename_ext = ".txt"; 
        let path = tmp_dir.display().to_string() + slash + &filename_front.to_string() + filename_ext;
        let file = File::create(path.clone());
        Ok(Self
        {
            file_path: path.into(),
            file: file?
        })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        std::fs::write(self.file_path.clone(), data).unwrap();
        Ok(())
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        let msg: String = fs::read_to_string(self.file_path.clone())?;
        Ok(msg)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}
pub fn main() {
    let temp = TempFile::new();
    println!("{:?}", temp);
    let array = [1,2,3,4,5];
    let written = temp.unwrap().write(&array);
    println!("{:?}", written);
}

Aurimas Kuniutis

auriku

3 months ago

6.67ms

87.97kb

use std::{
    fs::{self, File, OpenOptions},
    io::{Read, Write},
    path::PathBuf,
    time::{SystemTime, UNIX_EPOCH},
};
pub struct TempFile {
    pub file_path: PathBuf,
    pub file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let mut tmp_file_path = PathBuf::from(std::env::temp_dir());
        tmp_file_path.push(format!(
            "tmpfile_{}.tmp",
            SystemTime::now()
                .duration_since(UNIX_EPOCH)
                .unwrap()
                .as_nanos()
        ));
        let _ = fs::remove_file(&tmp_file_path);
        let file = std::fs::File::create_new(&tmp_file_path)?;
        Ok(Self {
            file_path: tmp_file_path,
            file,
        })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        let mut file = OpenOptions::new().write(true).open(&self.file_path)?;
        file.write(data)?;
        Ok(())
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        let mut file = OpenOptions::new().read(true).open(&self.file_path)?;
        let mut buffer = String::new();
        file.read_to_string(&mut buffer)?;
        Ok(buffer)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let _ = fs::remove_file(&self.file_path);
    }
}

mroslander

3 months ago

4.51ms

88.44kb

use std::path::PathBuf;
use std::fs::{remove_file, OpenOptions, File};
use std::time::SystemTime;
use std::io::{Read, Write};
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        // Your code here...
        let temp_name = SystemTime::now();
        let file_name = format!("{}/{:?}.txt", std::env::temp_dir().display(), temp_name);
        println!("ASDASD {}", file_name);
        let file = File::create(&file_name)?;
        Ok(TempFile {
            file_path: file_name.clone().into(), // TODO combine
            file,
        })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        self.file.write_all(data)?;
        Ok(())
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        // Your code here...
        let mut file = OpenOptions::new().read(true).open(&self.file_path)?;
        let mut buffer = String::new();
        let _ = file.read_to_string(&mut buffer);
        Ok(buffer)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        if let Err(e) = remove_file(&self.file_path) {
            eprintln!("Failed to delete file: {}", e);
        }
    }
}
 /*impl Drop for TempFile {
    fn drop(&mut self) {
        if let Err(e) = remove_file(&self.file_path) {
            eprintln!("Failed to delete temp file: {}", e);
        }
    }
}*/

Hung Dinh

nhdinh

3 months ago

6.28ms

87.55kb

use std::path::PathBuf;
use std::fs::{remove_file, OpenOptions, File};
use std::time::SystemTime;
use std::io::{Read, Write};
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let _ = remove_file(self.file_path.clone());
        ()
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let rand_name = SystemTime::now();
        let file_name = format!("{}/{:?}.txt", std::env::temp_dir().display(), rand_name);
        let file = File::create(&file_name)?;
        Ok(TempFile {
            file_path: file_name.clone().into(),
            file
        })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        self.file.write_all(data)?;
        Ok(())
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        // Your code here...
        let mut file = OpenOptions::new().read(true).open(&self.file_path)?;
        let mut buffer = String::new();
        file.read_to_string(&mut buffer)?;
        Ok(buffer)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}

FredoPo

3 months ago

10.63ms

87.94kb

use std::{fs::{self, write, File}, io::Error, path::PathBuf};
use std::time;
pub struct TempFile {
    file_path: PathBuf,
    file: File
}
impl Drop for TempFile {
    fn drop(&mut self) {
        fs::remove_file(&self.file_path);
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        // Your code here...
        let name = time::SystemTime::now();
        let filename = format!("file_{:?}.txt", name);
        let path: PathBuf = [r"/", "tmp", &filename].iter().collect();
        let file = File::create(path.clone()).map_err(|e| Error::new(std::io::ErrorKind::PermissionDenied, e))?;
        Ok(TempFile {
            file_path: path.clone(),
            file
        })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        // Your code here...
        write(self.file_path.clone(), data).map_err(|e| Error::new(std::io::ErrorKind::PermissionDenied, e))
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        // Your code here...
        let content = fs::read(self.file_path.clone()).map_err(|e| Error::new(std::io::ErrorKind::PermissionDenied, e))?;
        String::from_utf8(content).map_err(|e| Error::new(std::io::ErrorKind::InvalidData, e))
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}

Skippy

SkippyoftheWired

3 months ago

7.51ms

87.95kb

use std::path::PathBuf;
use std::fs::OpenOptions;
use std::fs::File;
use std::fs;
use std::io::prelude::*;
use std::time::{SystemTime, UNIX_EPOCH};
pub struct TempFile {
    file_path: PathBuf,
    file: File
}
impl Drop for TempFile {
    fn drop(&mut self) {
        fs::remove_file(&self.file_path);
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        // Your code here...
        let mut file_path = std::env::temp_dir();
        let file_suffix = SystemTime::now().duration_since(UNIX_EPOCH).expect("err").as_nanos();
        file_path.push(file_suffix.to_string());
        let file = File::create(&file_path)?;
        Ok(Self {
            file_path,
            file
        })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        // Your code here...
        let mut file = OpenOptions::new().write(true).open(&self.file_path)?;
        fs::write(&self.file_path, data)?;
        Ok(())
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        // Your code here...
        //let mut file = OpenOptions::new().read(true).open(&self.file_path)?;
        //let mut contents = String::new();
        //file.read_to_string(&mut contents)?;
        //Ok(contents)
        let contents = fs::read_to_string(&self.file_path)?;
        Ok(contents)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}

GermanS

3 months ago

6.38ms

88.02kb

use std::{
    fs::{File, OpenOptions},
    io::{Read, Write},
    path::PathBuf,
    time::{SystemTime, UNIX_EPOCH},
};
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        // Your code here...
        let tmpname = Self::tmpname();
        let path = std::env::temp_dir().join(tmpname);
        let file = File::create(&path)?;
        Ok(Self {
            file_path: path,
            file,
        })
    }
    fn tmpname() -> String {
        if let Ok(time) = SystemTime::now().duration_since(UNIX_EPOCH) {
            return format!("{}.txt", time.as_micros().to_string());
        }
        return "123.txt".into();
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        let mut file = OpenOptions::new().write(true).open(&self.file_path)?;
        file.write_all(data)?;
        Ok(())
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        let mut file = OpenOptions::new().read(true).open(&self.file_path)?;
        let mut buffer = String::new();
        file.read_to_string(&mut buffer)?;
        Ok(buffer)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let s = std::fs::remove_file(&self.file_path);
        if s.is_err() {
            eprint!("Error droping");
        }
    }
}

AtlasVakyrie

3 months ago

15.04ms

87.37kb

use std::path::PathBuf;
use std::fs::File;
use std::io::prelude::*;
use std::fs::OpenOptions;
pub struct TempFile {
    file_path: PathBuf,
    file: File
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let _ = std::fs::remove_file(self.file_path.as_path());
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let mut rng = File::open("/dev/urandom")?;
        let mut buffer = [0u8; 1];
        rng.read_exact(&mut buffer)?;
        let file_name = buffer[0];
        let file_path = PathBuf::from(format!("{}/{}", std::env::temp_dir().display(), file_name));
        let file = File::create(file_path.as_path())?;
        Ok(Self {
            file_path,
            file
        })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        self.file.write(data)?;
        Ok(())
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        let mut file = OpenOptions::new().read(true).open(&self.file_path)?;
        let mut buffer = String::new();
        file.read_to_string(&mut buffer)?;
        Ok(buffer)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}

Ahmet Özcan

ahmetoozcan

3 months ago

5.34ms

87.90kb

use std::{
    fs::{remove_file, File, OpenOptions},
    io::{Read, Write},
    path::PathBuf,
    time::{SystemTime, UNIX_EPOCH},
};
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        // Your code here...
        let start = SystemTime::now();
        let timestamp = start.duration_since(UNIX_EPOCH).expect("tf");
        let path = std::env::temp_dir().join(format!("/temp-{}", timestamp.as_micros()));
        let file = File::create(&path)?;
        Ok(TempFile {
            file_path: path,
            file,
        })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        // Your code here...
        OpenOptions::new()
            .write(true)
            .open(&self.file_path)?
            .write(data)
            .map(|_| ())
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        let mut buffer = String::new();
        OpenOptions::new()
            .read(true)
            .open(&self.file_path)?
            .read_to_string(&mut buffer)?;
        Ok(buffer)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        if let Err(e) = remove_file(&self.file_path) {
            eprintln!("Failed to delete temp file: {}", e);
        }
    }
}

Leif Hadsell

Booom775

4 months ago

5.07ms

87.98kb

use std::path::PathBuf;
use std::fs::{File, OpenOptions};
use std::io::{Write, Read};
use std::time::{SystemTime,UNIX_EPOCH};
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let now = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_micros();
        let mut temp_path = std::env::temp_dir();
        temp_path.push(format!("{}", now));
        let file = File::create(&temp_path)?;
        Ok(TempFile {
            file_path: temp_path,
            file
        })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        let mut file = OpenOptions::new().write(true).open(&self.file_path)?;
        file.write_all(data)?;
        Ok(())
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        let mut file = OpenOptions::new().read(true).open(&self.file_path)?;
        let mut buffer = String::new();
        file.read_to_string(&mut buffer)?;
        Ok(buffer)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let s = std::fs::remove_file(&self.file_path);
        if s.is_err() {
            eprint!("Error dropping");
        }
    }
}

Kishan Patel

KishanPatel4273

4 months ago

5.16ms

87.96kb

use std::fs::OpenOptions;
use std::fs::File;
use std::io::Read;
use std::io::Write;
use std::path::PathBuf;
use std::time::{SystemTime,UNIX_EPOCH};
pub struct TempFile {
    file_path: PathBuf,
    file: File
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        // Your code here...
        let now = SystemTime::now()
                    .duration_since(UNIX_EPOCH)
                    .unwrap()
                    .as_micros();
        let time_path: PathBuf = format!("{}", now).into();
                
        let file_path = std::env::temp_dir().join(time_path);
        let file = File::create(&file_path)?;
        Ok(
            Self {
                file_path,
                file
            }
        )
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        // Your code here...
        let mut file: File = OpenOptions::new().write(true).open(&self.file_path)?;
        file.write(data)?;
        Ok(())
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        // Your code here...
        let mut buf = String::new();
        let mut file: File = OpenOptions::new().read(true).open(&self.file_path)?;
        file.read_to_string(&mut buf)?;
        Ok(buf)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let s = std::fs::remove_file(&self.file_path);
        if s.is_err() {
            eprint!("Error dropping");
        }
    }
}

ckab

ckab04

4 months ago

5.37ms

87.56kb

use std::{fs::{File, OpenOptions}, io::{Read, Write}, path::PathBuf, time::{SystemTime, UNIX_EPOCH}};
pub struct TempFile {
 file_path: PathBuf,
    file: File
}
impl Drop for TempFile {
    fn drop(&mut self) {
        if let Err(e) = std::fs::remove_file(&self.file_path) {
            eprintln!("Error removing temporary file: {}", e);
        }
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        // Your code here...
        let now = SystemTime::now()
                    .duration_since(UNIX_EPOCH)
                    .unwrap()
                    .as_micros();
                let file_path: PathBuf = format!("{}", now).into();
                let path = std::env::temp_dir().join(file_path);
                let f = OpenOptions::new()
                    .create(true)
                    .read(true)
                    .write(true)
                    .open(&path)?;
                Ok(TempFile {
                    file_path: path,
                    file: f,
                })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        // Your code here...
         self.file.write_all(data)?;
        Ok(())
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        // Your code here...
        let mut file = OpenOptions::new().read(true).open(&self.file_path)?;
        let mut file_content = String::new();
        let _ = file.read_to_string(&mut file_content)?;
        Ok(file_content)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}

Trevor Kann

TrevorGKann

4 months ago

5.20ms

88.04kb

use std::fs::File;
use std::path::Path;
use std::path::PathBuf;
use std::fs::OpenOptions;
use std::io::{Write, Read};
use std::env;
use std::time::SystemTime;
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl Drop for TempFile {
    fn drop(&mut self) {
        // Ensure the file is deleted when TempFile is dropped
        if let Err(e) = std::fs::remove_file(&self.file_path) {
            eprintln!("Failed to delete file: {}", e);
        }
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        // Your code here...
        let tstamp = SystemTime::now()
            .duration_since(SystemTime::UNIX_EPOCH)
            .unwrap()
            .subsec_micros();
        let pid = std::process::id();
        let file_path = env::temp_dir().join(format!("tempfile_{}_{}.text", tstamp, pid));
        let file = File::create(&file_path)?;
        Ok(Self {
            file_path,
            file
        })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        // Your code here...
        let mut file = OpenOptions::new().write(true).open(&self.file_path)?;
        file.write_all(data)?;
        Ok(())
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        // Your code here...
        let mut file = OpenOptions::new().read(true).open(&self.file_path)?;
        let mut buffer = String::new();
        file.read_to_string(&mut buffer)?;
        Ok(buffer)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}

Christopher Nielson

c-nielson

4 months ago

5.34ms

87.56kb

use std::fs::{File, OpenOptions};
use std::io::{Read, Write};
use std::path::PathBuf;
use std::time::SystemTime;
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl Drop for TempFile {
    fn drop(&mut self) {
        if let Err(e) = std::fs::remove_file(&self.file_path) {
            eprintln!("Error removing temporary file: {}", e);
        }
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let mut path = std::env::temp_dir();
        path.push(SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap().as_micros().to_string());
        let file = File::create(&path)?;
        Ok(Self {
            file_path: path,
            file,
        })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        let mut writer = OpenOptions::new().write(true).open(&self.file_path)?;
        writer.write_all(data)
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        let mut reader = OpenOptions::new().read(true).open(&self.file_path)?;
        let mut buffer = String::new();
        reader.read_to_string(&mut buffer)?;
        Ok(buffer)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}

codervijo

4 months ago

5.12ms

88.04kb

use std::fs::File;
use std::path::Path;
use std::path::PathBuf;
use std::fs::OpenOptions;
use std::io::{Write, Read};
use std::env;
use std::time::SystemTime;
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl Drop for TempFile {
    fn drop(&mut self) {
        // Ensure the file is deleted when TempFile is dropped
        if let Err(e) = std::fs::remove_file(&self.file_path) {
            eprintln!("Failed to delete file: {}", e);
        }
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        // Your code here...
        let tstamp = SystemTime::now()
            .duration_since(SystemTime::UNIX_EPOCH)
            .unwrap()
            .subsec_micros();
        let pid = std::process::id();
        let file_path = env::temp_dir().join(format!("tempfile_{}_{}.text", tstamp, pid));
        let file = File::create(&file_path)?;
        Ok(Self {
            file_path,
            file
        })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        // Your code here...
        let mut file = OpenOptions::new().write(true).open(&self.file_path)?;
        file.write_all(data)?;
        Ok(())
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        // Your code here...
        let mut file = OpenOptions::new().read(true).open(&self.file_path)?;
        let mut buffer = String::new();
        file.read_to_string(&mut buffer)?;
        Ok(buffer)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}

Leandro Abreu

leandronowras

4 months ago

4.70ms

87.57kb

use std::{
    fs::{remove_file, File, OpenOptions},
    io::{Read, Write},
    path::PathBuf,
    time::{SystemTime, UNIX_EPOCH},
};
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let now = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_micros();
        let file_path: PathBuf = format!("{}", now).into();
        let fp = std::env::temp_dir().join(file_path);
        let f = OpenOptions::new()
            .create(true)
            .read(true)
            .write(true)
            .open(&fp)?;
        Ok(TempFile {
            file_path: fp,
            file: f,
        })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        self.file.write_all(data)
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        let mut file = OpenOptions::new().read(true).open(&self.file_path)?;
        let mut buf = String::new();
        file.read_to_string(&mut buf)?;
        Ok(buf)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        if let Err(e) = remove_file(&mut self.file_path) {
            eprintln!("Failed to delete temprorary file: {}", e);
        }
    }
}

Ido Barkan

barkanido

5 months ago

4.51ms

87.57kb

use std::{
    fs::{remove_file, File, OpenOptions},
    io::{Read, Write},
    path::PathBuf,
    time::{SystemTime, UNIX_EPOCH},
};
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let now = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_micros();
        let file_path: PathBuf = format!("{}", now).into();
        let fp = std::env::temp_dir().join(file_path);
        let f = OpenOptions::new()
            .create(true)
            .read(true)
            .write(true)
            .open(&fp)?;
        Ok(TempFile {
            file_path: fp,
            file: f,
        })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        self.file.write_all(data)
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        let mut file = OpenOptions::new().read(true).open(&self.file_path)?;
        let mut buf = String::new();
        file.read_to_string(&mut buf)?;
        Ok(buf)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        if let Err(e) = remove_file(&mut self.file_path) {
            eprintln!("Failed to delete temprorary file: {}", e);
        }
    }
}

Artem

CaptainBloodborne

5 months ago

4.47ms

87.63kb

use std::io::{Read, Write};
use std::path::PathBuf;
use std::fs::{File, remove_file, OpenOptions};
// use std::time::{SystemTime, UNIX_EPOCH};
fn get_uuid() -> Result<String, std::io::Error> {
    let mut file = OpenOptions::new()
        .read(true)
        .open("/proc/sys/kernel/random/uuid")?;
    let mut buf = String::new();
    file.read_to_string(&mut buf)?;
    Ok(buf)
}
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        // let tempfile_name = SystemTime::now()
        //     .duration_since(UNIX_EPOCH)
        //     .unwrap()
        //     .as_secs_f64();
        // let tmp_name = format!("tempfile_{}", tempfile_name);
        let fp = std::env::temp_dir().join(format!("tempfile-{}", get_uuid()?));
        // let fp = PathBuf::from("tempfile");
        let f = OpenOptions::new()
            .create(true)
            .read(true)
            .write(true)
            .open(&fp);
        f.map(|f| Self{file_path: fp, file: f})
        
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        // Your code here...
        let mut file = OpenOptions::new()
            .write(true)
            .open(&self.file_path)?;
        file.write_all(data)?;
        Ok(())
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        // Your code here...
        let mut file = OpenOptions::new()
            .read(true)
            .open(&self.file_path)?;
        let mut buf = String::new();
        file.read_to_string(&mut buf)?;
        Ok(buf)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
       if let Err(e) = remove_file(&mut self.file_path){
           eprintln!("Failed to delete temprorary file: {}", e); 
       }
    }
}

Artem

CaptainBloodborne

5 months ago

4.64ms

87.59kb

use std::io::{Read, Write};
use std::path::PathBuf;
use std::fs::{File, remove_file, OpenOptions};
use std::time::{SystemTime, UNIX_EPOCH};
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let tempfile_name = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_secs_f64();
        let tmp_name = format!("tempfile_{}", tempfile_name);
        let fp = std::env::temp_dir().join(tmp_name);
        // let fp = PathBuf::from("tempfile");
        let f = OpenOptions::new()
            .create(true)
            .read(true)
            .write(true)
            .open(&fp);
        f.map(|f| Self{file_path: fp, file: f})
        
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        // Your code here...
        let mut file = OpenOptions::new()
            .write(true)
            .open(&self.file_path)?;
        file.write_all(data)?;
        Ok(())
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        // Your code here...
        let mut file = OpenOptions::new()
            .read(true)
            .open(&self.file_path)?;
        let mut buf = String::new();
        file.read_to_string(&mut buf)?;
        Ok(buf)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
       if let Err(e) = remove_file(&mut self.file_path){
           eprintln!("Failed to delete temprorary file: {}", e); 
       }
    }
}

Kj

kj-9

5 months ago

5.90ms

87.55kb

use std;
use std::fs::File;
use std::path::PathBuf;
use std::fs::OpenOptions;
use std::io::Write;
use std::io::Read;
use std::time::{SystemTime};
pub struct TempFile {
    file_path: std::path::PathBuf,
    file: std::fs::File
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        // Your code here...
        let file_dir = std::env::temp_dir();
        let file_path = file_dir.join(format!("tempfile-{:?}", SystemTime::now()));
        let file = std::fs::File::create(&file_path).unwrap();
        Ok(Self {
            file_path,
            file
        })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        // Your code here...
        let mut file = OpenOptions::new().write(true).open(&self.file_path)?;
        file.write(data)?;
        Ok(())
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        // Your code here...
        let mut file = OpenOptions::new().read(true).open(&self.file_path)?;
        let mut buffer = String::new();
        file.read_to_string(&mut buffer)?;
        Ok(buffer)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
       let _ = std::fs::remove_file(self.path());
    }
}

gsspdev

5 months ago

4.74ms

87.97kb

use std::fs::File;
use std::io::{Read, Write};
use std::ops::Drop;
use std::path::PathBuf;
use std::time::{SystemTime, UNIX_EPOCH};
pub struct TempFile {
    pub file_path: PathBuf,
    pub file: File,
}
// Not really random, but there isn't a std random number function anymore
fn random_name() -> String {
    let nanos = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap()
        .subsec_nanos();
    format!("temp-{}", nanos)
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let mut file_path = PathBuf::new();
        file_path.push("/tmp");
        file_path.push(random_name());
        let mut file = File::options().read(true).write(true).create(true).open(file_path.clone())?;
        Ok(TempFile {
            file_path, file
        })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        let mut file = File::options().write(true).open(self.file_path.clone())?;
        file.write_all(data)
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        let mut file = File::open(self.file_path.clone())?;
        let mut result = String::new();
        file.read_to_string(&mut result)?;
        Ok(result)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let rm_result = std::fs::remove_file(self.file_path.clone());
        if let Err(e) = rm_result {
            if e.kind() != std::io::ErrorKind::NotFound {
                panic!("Failure deleting temp file: {}", e.to_string())
            }
        }
    }
}

Derek Chen-Becker

dchenbecker

5 months ago

4.68ms

87.97kb

use std::fs::File;
use std::io::{Read, Write};
use std::ops::Drop;
use std::path::PathBuf;
use std::time::{SystemTime, UNIX_EPOCH};
pub struct TempFile {
    pub file_path: PathBuf,
    pub file: File,
}
// Not really random, but there isn't a std random number function anymore
fn random_name() -> String {
    let nanos = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap()
        .subsec_nanos();
    format!("temp-{}", nanos)
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let mut file_path = PathBuf::new();
        file_path.push("/tmp");
        file_path.push(random_name());
        let mut file = File::options().read(true).write(true).create(true).open(file_path.clone())?;
        Ok(TempFile {
            file_path, file
        })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        let mut file = File::options().write(true).open(self.file_path.clone())?;
        file.write_all(data)
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        let mut file = File::open(self.file_path.clone())?;
        let mut result = String::new();
        file.read_to_string(&mut result)?;
        Ok(result)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let rm_result = std::fs::remove_file(self.file_path.clone());
        if let Err(e) = rm_result {
            if e.kind() != std::io::ErrorKind::NotFound {
                panic!("Failure deleting temp file: {}", e.to_string())
            }
        }
    }
}

Duncan Macharia

Devdannetworks

5 months ago

6.04ms

87.60kb

use std::env::temp_dir;
use std::fs::{File, OpenOptions, remove_file};
use std::io::{self, Write, Read};
use std::path::PathBuf;
use std::time::{SystemTime, UNIX_EPOCH};
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let temp_dir = temp_dir();
        let timestamp = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?
            .as_nanos();
        let file_path = temp_dir.join(format!("tempfile_{}", timestamp));
        let file = File::create(&file_path)?;
        Ok(Self { file_path, file })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        self.file.write_all(data)
    }
    pub fn read_to_string(&self) -> Result<String, std::io::Error> {
        let mut file = OpenOptions::new().read(true).open(&self.file_path)?;
        let mut buffer = String::new();
        file.read_to_string(&mut buffer)?;
        Ok(buffer)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
}
// Implement Drop to handle file deletion
impl Drop for TempFile {
    fn drop(&mut self) {
        if let Err(e) = remove_file(&self.file_path) {
            eprintln!("Failed to delete temporary file {}: {}", self.file_path.display(), e);
        }
    }
}

Antoine Plard

tylp

5 months ago

5.73ms

87.37kb

use std::path::PathBuf;
use std::fs::File;
use std::io::prelude::*;
use std::fs::OpenOptions;
pub struct TempFile {
    file_path: PathBuf,
    file: File
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let _ = std::fs::remove_file(self.file_path.as_path());
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let mut rng = File::open("/dev/urandom")?;
        let mut buffer = [0u8; 1];
        rng.read_exact(&mut buffer)?;
        let file_name = buffer[0];
        let file_path = PathBuf::from(format!("{}/{}", std::env::temp_dir().display(), file_name));
        let file = File::create(file_path.as_path())?;
        Ok(Self {
            file_path,
            file
        })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        self.file.write(data)?;
        Ok(())
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        let mut file = OpenOptions::new().read(true).open(&self.file_path)?;
        let mut buffer = String::new();
        file.read_to_string(&mut buffer)?;
        Ok(buffer)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}

Job Matheka

jobm

5 months ago

4.99ms

87.86kb

use std::env::temp_dir;
use std::fs::{File, OpenOptions};
use std::io::{Read, Write};
use std::path::PathBuf;
use std::time::{SystemTime, UNIX_EPOCH};
use std::process;
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl Drop for TempFile {
    fn drop(&mut self) {
        std::fs::remove_file(&self.file_path);
        std::fs::remove_dir(&self.file_path);
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        // Your code here...
        let timestamp = SystemTime::now()
                .duration_since(UNIX_EPOCH)
                .unwrap()
                .as_nanos();
        let process_id = process::id();
        let file_name = format!("temp_{}_{}.txt", timestamp, process_id);
        let path = temp_dir().join(file_name);
        let file = File::create(&path)?;
        Ok(TempFile {
            file,
            file_path: path,
        })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        // Your code here...
        let mut file = OpenOptions::new().write(true).open(&self.file_path)?;
        file.write(data)?;
        Ok(())
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        // Your code here...
        let mut file = OpenOptions::new().read(true).open(&self.file_path)?;
        let mut buffer = String::new();
        file.read_to_string(&mut buffer)?;
        Ok(buffer)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}

isaaclv

5 months ago

5.88ms

87.53kb

use std::path::PathBuf;
use std::fs::{File, OpenOptions, remove_file};
use std::io::{Read, Write};
use std::time::{SystemTime};
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl Drop for TempFile {
    fn drop(&mut self) {
        match remove_file(&self.file_path) { 
            Ok(_) => {},
            Err(e) => println!("Error removing file. {}", e),
        }
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let mut tmp_dir = std::env::temp_dir();
        let file_name = SystemTime::now()
            .duration_since(SystemTime::UNIX_EPOCH)
            .unwrap()
            .as_nanos()
            .to_string();
        tmp_dir.push(file_name);
        let file = File::create(&tmp_dir)?;
        return Ok(Self { file_path: tmp_dir, file: file });
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        let mut file = OpenOptions::new().write(true).open(&self.file_path)?;
        file.write_all(data)?;
        Ok(())
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
      let mut file = OpenOptions::new().read(true).open(&self.file_path)?;
      let mut buffer = String::new();
      file.read_to_string(&mut buffer)?;
      Ok(buffer)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}

isaaclv

5 months ago

4.63ms

87.53kb

use std::path::PathBuf;
use std::fs::{File, OpenOptions, remove_file};
use std::io::{Read, Write};
use std::time::{SystemTime};
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl Drop for TempFile {
    fn drop(&mut self) {
        match remove_file(&self.file_path) { 
            Ok(_) => {},
            Err(e) => println!("Error removing file. {}", e),
        }
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let mut tmp_dir = std::env::temp_dir();
        let file_name = SystemTime::now()
            .duration_since(SystemTime::UNIX_EPOCH)
            .unwrap()
            .as_nanos()
            .to_string();
        tmp_dir.push(file_name);
        let file = File::create(&tmp_dir)?;
        return Ok(Self { file_path: tmp_dir, file: file });
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        self.file.write_all(data)
        // let mut file = OpenOptions::new().write(true).open(&self.file_path)?;
        // file.write_all(data)?;
        // Ok(())
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
      let mut file = OpenOptions::new().read(true).open(&self.file_path)?;
      let mut buffer = String::new();
      file.read_to_string(&mut buffer)?;
      Ok(buffer)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}

Grant Kinney

creativecoder

5 months ago

5.16ms

87.95kb

use std::path::PathBuf;
use std::fs::{File, remove_file};
use std::time::UNIX_EPOCH;
use std::io::{Seek, Read, Write};
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let mut file_path = std::env::temp_dir();
        let file_name = UNIX_EPOCH
            .elapsed()
            .unwrap()
            .as_nanos()
            .to_string();
        file_path.push(file_name);
        
        let file = File::options()
            .create(true)
            .read(true)
            .write(true)
            .open(&file_path)?;
        let temp_file = Self {
            file_path,
            file,
        };
        Ok(temp_file)
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        self.file.write_all(data)?;
        Ok(())
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        self.file.rewind()?;
        let mut contents = String::new();
        self.file.read_to_string(&mut contents)?;
        Ok(contents)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let _ = remove_file(&self.file_path);
    }
}

Psychloor

5 months ago

5.53ms

87.96kb

use std::fs::{File, OpenOptions};
use std::io::{Read, Write};
use std::path::PathBuf;
use std::time::SystemTime;
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let mut file_path = std::env::temp_dir();
        file_path.push(format!("{}", SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap().as_nanos()));
        
        let file = File::create(&file_path)?;
        let temp_file = Self {
            file_path,
            file,
        };
        Ok(temp_file)
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        let mut file = OpenOptions::new().write(true).open(&self.file_path)?;
        file.write_all(data)?;
        Ok(())
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        let mut file = OpenOptions::new().read(true).open(&self.file_path)?;
        let mut contents = String::new();
        file.read_to_string(&mut contents)?;
        Ok(contents)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        if let Err(e) = std::fs::remove_file(&self.file_path) {
            eprintln!("Error removing temp file: {}", e);
        }
    }
}

arilet

5 months ago

5.03ms

87.41kb

use std::fs::File;
use std::fs::OpenOptions;
use std::fs;
use std::path::PathBuf;
use std::io::Write;
use std::io::Read;
use std::time::{SystemTime, UNIX_EPOCH};
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl Drop for TempFile {
    fn drop(&mut self) {
        fs::remove_file(self.file_path.clone());
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        // Your code here...
        let mut tmppath = std::env::temp_dir();
        let systemtime = SystemTime::now().
            duration_since(UNIX_EPOCH).unwrap().
            subsec_nanos();
        tmppath.push(systemtime.to_string());
        let tmpfile = File::create(tmppath.clone())?;
        Ok(TempFile { file_path: tmppath, file: tmpfile })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        // Your code here...
        let mut file = OpenOptions::new().write(true).open(&self.file_path)?;
        file.write_all(data)?;
        Ok(())
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        // Your code here...
        let mut file = OpenOptions::new().read(true).open(&self.file_path)?;
        let mut buffer = String::new();
        file.read_to_string(&mut buffer)?;
        Ok(buffer)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}

Ferdinand de Baecque

Ferdinanddb

5 months ago

4.67ms

87.78kb

use std::env;
use std::fs::{remove_file, File, OpenOptions};
use std::io::{Read, Write};
use std::path::PathBuf;
use std::time::SystemTime;
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        // Your code here...
        let file_name = SystemTime::now()
            .duration_since(SystemTime::UNIX_EPOCH)
            .unwrap()
            .as_nanos()
            .to_string();
        let tmp_dir = env::temp_dir();
        let file_path = tmp_dir.join(file_name);
        let file = File::create(&file_path)?;
        Ok(
            Self {
                file_path,
                file
            }
        )
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        // Your code here...
        let mut file = OpenOptions::new().write(true).open(&self.file_path)?;
        file.write_all(data)?;
        Ok(())
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        // Your code here...
        let mut file = OpenOptions::new().read(true).open(&self.file_path)?;
        let mut buffer = String::new();
        file.read_to_string(&mut buffer)?;
        Ok(buffer)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let _ = remove_file(&self.file_path);
    }
}

Francisco López

franlopezm

5 months ago

4.52ms

87.78kb

use std::{
    env,
    fs::{File, OpenOptions, remove_file},
    io::{Read, Write},
    path::PathBuf,
    time::SystemTime
};
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let file_name = SystemTime::now()
            .duration_since(SystemTime::UNIX_EPOCH)
            .unwrap()
            .as_nanos()
            .to_string();
        let file_path = env::temp_dir().join(&file_name);
        let file = File::create(&file_path)?;
        Ok(
            Self {
                file_path,
                file
            }
        )
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        let mut file = OpenOptions::new()
            .write(true)
            .open(&self.file_path)?;
        file.write(data)?;
        Ok(())
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        let mut file = OpenOptions::new()
            .read(true)
            .open(&self.file_path)?;
        let mut buffer = String::new();
        file.read_to_string(&mut buffer)?;
        Ok(buffer)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let _ = remove_file(&self.file_path);
    }
}

Chase Walden

chasewalden

5 months ago

4.44ms

87.81kb

use std::{
    env,
    fs::{self, File},
    hash::{BuildHasher, RandomState},
    io::{self, Write, Seek},
    mem::ManuallyDrop,
    path::PathBuf,
    time,
};
pub struct TempFile {
    pub file_path: PathBuf,
    pub file: ManuallyDrop<File>,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        
        let now = time::UNIX_EPOCH.elapsed() // should never fail, but just in case...
            .map_err(|_| io::Error::other("unable to get timestamp"))?;
        let random_name = format!(
            "jinglestack-{}-{:0width$x}", 
            now.as_secs(),
            RandomState::new().hash_one(now.subsec_nanos()),
            width = u64::BITS as usize / 4,
        );
        let file_path = env::temp_dir().join(random_name);
        // technically we should lazy-init the file
        let file = File::create_new(&file_path).map(ManuallyDrop::new)?;
        Ok(Self {file_path, file})
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        self.file.write_all(data)
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        self.file.rewind()?;
        io::read_to_string(&mut *self.file) // should reset cursor to end
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}
impl Drop for TempFile {
   fn drop(&mut self) {
        // SAFETY: this should be dropped before the file is deleted
        // The `File` struct does not have a `delete` method
        unsafe { ManuallyDrop::drop(&mut self.file); }
        let _ = fs::remove_file(&self.file_path); // ignore error
    }
}

Sergei Chertkov

mamont

5 months ago

5.10ms

87.96kb

use std::env;
use std::fs::{ File, remove_file};
use std::fs::OpenOptions;
use std::path::PathBuf;
use std::io::{Read, Write};
use std::time::{SystemTime, UNIX_EPOCH};
pub struct TempFile {
    file: File,
    file_path: PathBuf,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let mut file_path: PathBuf = env::temp_dir();
        let current_time = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_nanos();
        let unique_name = format!("temp-{}.tmp", current_time);
        file_path.push(unique_name);
        let file = File::create(&file_path)?;
        Ok(
            TempFile {
                file: file,
                file_path: file_path
            }
        )
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        let mut file = OpenOptions::new().write(true).open(&self.file_path)?;
        file.write_all(data)
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        let mut file = OpenOptions::new().read(true).open(&self.file_path)?;
        let mut buffer = String::new();
        file.read_to_string(&mut buffer)?;
        Ok(buffer)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let _ = remove_file(&self.file_path);
    }
}

Kinuko Yasuda

kinu

5 months ago

6.35ms

87.46kb

use std::path::PathBuf;
use std::fs::{File,OpenOptions,remove_file};
use std::io::{Read,Seek,Write};
use std::time::SystemTime;
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        // Your code here...
        let mut file_path = std::env::temp_dir();
        file_path.push(format!("aor-21-{}",
                SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap().as_nanos()));
        let file = OpenOptions::new()
            .read(true)
            .write(true)
            .create(true)
            .open(&file_path)?;
        Ok(Self { file_path, file })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        // Your code here...
        self.file.write(data)?;
        Ok(())
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        // Your code here...
        let mut content = String::new();
        self.file.seek(std::io::SeekFrom::Start(0))?;
        self.file.read_to_string(&mut content)?;
        Ok(content)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        remove_file(self.file_path.clone());
    }
}