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

joshvon44

5 hours ago

4.00ms

87.95kb

use std::fs::{remove_file, File};
use std::io::Read;
use std::io::Seek;
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> {
        let mut file_path = std::env::temp_dir();
        let now = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
        file_path.push(now.as_nanos().to_string());
        let file = File::options()
            .read(true)
            .write(true)
            .truncate(true)
            .create(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)?;
        Ok(())
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        // Your code here...
        let mut result = String::new();
        self.file.rewind()?;
        self.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) {
        // drop(&self.file);
        let _ = remove_file(&self.file_path);
    }
}

Aaron

aaron-otis

6 hours ago

5.15ms

87.99kb

use std::fs::{File, OpenOptions, remove_file};
use std::env::temp_dir;
use std::io::{Read, 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 mut file_path = temp_dir();
        let now = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .map_err(|_| std::io::Error::new(std::io::ErrorKind::Other, "traveled back in time"))?;
        let name: String = format!("temp-{}", now.as_nanos());
        file_path.set_file_name(&name);
        let file = File::create_new(&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(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);
    }
}

Joseph Copenhaver

josephcopenhaver

8 hours ago

4.53ms

87.95kb

use std::fs::OpenOptions;
use std::path::PathBuf;
use std::fs::remove_file;
use std::fs::File;
use std::io::Read;
use std::io::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> {
        let mut file_path = std::env::temp_dir();
        let now = SystemTime::now().duration_since(UNIX_EPOCH).expect("system time is currently before unix epoch");
        file_path.push(format!("rando_filerizian_{:?}", now.as_nanos()));
        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 f = OpenOptions::new().read(true).open(&self.file_path)?;
        let mut buf = String::new();
        f.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) {
        // tests seem to want errors to be ignored
        let _ = remove_file(&self.file_path);
    }
}

Ljungg

9 hours ago

4.36ms

87.95kb

use std::{
    env,
    fs::{self, File, OpenOptions},
    io::{Read, Write},
    path::PathBuf,
};
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let _ = fs::remove_file(&self.file_path);
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let mut file_path = env::temp_dir();
        file_path.push(
            std::time::UNIX_EPOCH
                .elapsed()
                .unwrap()
                .as_nanos()
                .to_string(),
        );
        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(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
    }
}

The Scooby

thescooby

10 hours ago

5.08ms

87.47kb

use std::path::PathBuf;
use std::time::{SystemTime, UNIX_EPOCH};
use std::fs::{File, OpenOptions};
use std::io::{Write, Read};
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let _ = std::fs::remove_file(&self.file_path);
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let mut tmp_file_path = std::env::temp_dir();
        tmp_file_path.push(format!("12345678-{:?}.txt", SystemTime::now().duration_since(UNIX_EPOCH)));
        Ok(TempFile  {
            file_path: tmp_file_path.clone(),
            file: File::create(tmp_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)?;
        Ok(())
    }
    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
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}

Morse

A1-exe

10 hours ago

4.45ms

87.48kb

use std::{env, fs, fs::{ File, OpenOptions}, path::PathBuf};
use std::io::{Write, 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);
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let mut file_path = env::temp_dir();
        file_path.push(format!("test{:?}.txt", SystemTime::now().duration_since(UNIX_EPOCH)));
        let file = File::create(&file_path)?;
        Ok(TempFile{
            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_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
    }
}

Rickard Jensen

rjensen

12 hours ago

4.39ms

87.78kb

use std::fs;
use std::fs::{File, OpenOptions};
use std::io::{Read, Write};
use std::path::PathBuf;
use std::time::UNIX_EPOCH;
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl Drop for TempFile{
    fn drop(&mut self) {
        let _ = fs::remove_file(&self.file_path);
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        // Your code here...
        let filename = UNIX_EPOCH.elapsed().unwrap().as_nanos().to_string();
        let file_path = std::env::temp_dir().join(filename);
        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
    }
}

Florian Gaudin-Delrieu

FlorianGD

13 hours ago

5.54ms

87.95kb

use std::fs::File;
use std::io::prelude::*;
use std::path::PathBuf;
use std::fs::OpenOptions;
use std::time::{SystemTime, UNIX_EPOCH};
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let _ = std::fs::remove_file(&self.file_path);
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let mut path = std::env::temp_dir();
        let file_suffix = SystemTime::now().duration_since(UNIX_EPOCH).expect("err").as_nanos();
        path.push(file_suffix.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 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
    }
}

Mingzhe Yang

mei28

15 hours ago

5.80ms

87.95kb

use std::fs::{self, OpenOptions};
use std::{fs::File, path::PathBuf};
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) {
        let _ = fs::remove_file(&self.file_path);
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        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)?;
        // file.write_all(data)?;
        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
    }
}

Mingzhe Yang

mei28

15 hours ago

5.87ms

87.95kb

use std::fs::{self, OpenOptions};
use std::{fs::File, path::PathBuf};
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) {
        let _ = fs::remove_file(&self.file_path);
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        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)?;
        // file.write_all(data)?;
        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
    }
}

sweet2honey

15 hours ago

7.87ms

87.48kb

use std::{env, fs, fs::{ File, OpenOptions}, path::PathBuf};
use std::io::{Write, 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);
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let mut file_path = env::temp_dir();
        file_path.push(format!("test{:?}.txt", SystemTime::now().duration_since(UNIX_EPOCH)));
        let file = File::create(&file_path)?;
        Ok(TempFile{
            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_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
    }
}

pagyeman

16 hours ago

3.96ms

87.48kb

use std::{env, fs, fs::{ File, OpenOptions}, path::PathBuf};
use std::io::{Write, 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);
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let mut file_path = env::temp_dir();
        file_path.push(format!("test{:?}.txt", SystemTime::now().duration_since(UNIX_EPOCH)));
        let file = File::create(&file_path)?;
        Ok(TempFile{
            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_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
    }
}

kosay

sarub0b0

17 hours ago

4.44ms

87.99kb

use std::fs::File;
use std::io::{Read, Write};
use std::path::PathBuf;
use std::time::SystemTime;
pub struct TempFile {
    field_path: PathBuf,
    file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let mut temp_dir = std::env::temp_dir();
        let file_name = SystemTime::now()
            .duration_since(SystemTime::UNIX_EPOCH)
            .expect("error")
            .as_nanos()
            .to_string();
        temp_dir.push(file_name);
        let file = File::create_new(temp_dir.clone())?;
        Ok(Self {
            field_path: temp_dir,
            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 = File::open(self.field_path.clone())?;
        let mut contents = String::new();
        file.read_to_string(&mut contents)?;
        Ok(contents)
    }
    pub fn path(&self) -> &PathBuf {
        &self.field_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let _ = std::fs::remove_file(self.field_path.clone());
    }
}

PangoSea

kapaseker

19 hours ago

5.60ms

87.95kb

use std::fs::{self, OpenOptions};
use std::{fs::File, path::PathBuf};
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) {
        let _ = fs::remove_file(&self.file_path);
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        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)?;
        // file.write_all(data)?;
        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
    }
}

Wendy Kong

wendko

a day ago

5.88ms

87.95kb

use std::fs::{self, OpenOptions};
use std::{fs::File, path::PathBuf};
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) {
        let _ = fs::remove_file(&self.file_path);
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        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)?;
        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 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
    }
}

Emmanuel Guefif

eguefif

a day ago

4.57ms

87.48kb

use std::path::PathBuf;
use std::fs::File;
use std::fs::OpenOptions;
use std::env;
use std::fs;
use std::io::{Write, 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);
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let mut file_path = env::temp_dir();
        file_path.push(format!("test{:?}.txt", SystemTime::now().duration_since(UNIX_EPOCH)));
        let file = File::create(&file_path)?;
        Ok(TempFile{
            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_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
    }
}

Marius Gehrmann

MGehrmann

a day ago

6.09ms

87.53kb

use std::path::PathBuf;
use std::fs::{File, remove_file};
use std::fs::OpenOptions;
use std::io::prelude::*;
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)?;
        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
    }
}

Kushneryk Pavel

KushnerykPavel

a day ago

4.88ms

87.92kb

use std::path::PathBuf;
use std::fs::{File, OpenOptions};
use std::io::Read;
use std::io::Write;
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(_) = std::fs::remove_file(&self.file_path) {
            println!("Failed to remove file");
        }
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        // Your code here...
        let mut file_path = std::env::temp_dir();
        let unix_epoch = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
        file_path.push(format!("temp_{}.tmp", unix_epoch.as_nanos()));
        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(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
    }
}

Habu

habu1010

a day ago

5.70ms

87.96kb

use std::path::PathBuf;
use std::fs::{File, OpenOptions};
use std::io::Read;
use std::io::Write;
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(_) = std::fs::remove_file(&self.file_path) {
            println!("Failed to remove file");
        }
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        // Your code here...
        let mut file_path = std::env::temp_dir();
        let unix_epoch = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
        file_path.push(format!("temp_{}.tmp", unix_epoch.as_nanos()));
        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(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
    }
}

Denis

overplumbum

a day ago

4.95ms

87.78kb

use std::path::PathBuf;
use std::fs::File;
use std::fs::OpenOptions;
use std::io::Write;
use std::io::Read;
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl Drop for TempFile {
     fn drop(&mut self) {
        std::fs::remove_file(&self.file_path);
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let nobueno = std::time::UNIX_EPOCH.elapsed().unwrap().as_nanos().to_string();
        let file_path = std::env::temp_dir().join(nobueno);
        let file = File::create(&file_path)?;
        Ok(Self{
            file_path: file_path,
            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
    }
}

wishkus

a day ago

4.52ms

87.84kb

use std::path::PathBuf;
use std::fs;
use std::env;
use std::io::prelude::*;
pub struct TempFile {
    file_path: PathBuf,
    file: fs::File
}
impl Drop for TempFile {
    fn drop(&mut self) {
        if let Err(_) = fs::remove_file(&self.file_path) {
            println!("File is already removed");
        }
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let mut file_path = env::temp_dir();
        file_path.push(std::time::UNIX_EPOCH.elapsed().unwrap().as_nanos().to_string());
        let file = fs::File::create(&file_path)?;
        Ok(Self {
            file_path: file_path,
            file: file
        })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        let mut file = fs::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 = fs::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) -> &fs::File {
        &self.file
    }
}

wishkus

a day ago

4.82ms

87.81kb

use std::path::PathBuf;
use std::fs;
use std::env;
use std::io::prelude::*;
pub struct TempFile {
    file_path: PathBuf,
    file: fs::File
}
impl Drop for TempFile {
    fn drop(&mut self) {
        if let Err(_) = fs::remove_file(&self.file_path) {
            println!("File is already removed");
        }
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let mut file_path = env::temp_dir();
        file_path.push(std::time::UNIX_EPOCH.elapsed().unwrap().as_nanos().to_string());
        let file = fs::File::create(&file_path)?;
        Ok(Self {
            file_path: file_path,
            file: file
        })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        let mut file = fs::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 = fs::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) -> &fs::File {
        &self.file
    }
}

Vladimir Fedorov

Fedott

a day ago

5.51ms

87.43kb

use std::fs;
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) {
        match fs::remove_file(&self.file_path) {
            Ok(_) => {}
            Err(_) => {}
        }
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let mut path_buf = std::env::temp_dir();
        let file_name = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap().as_nanos().to_string();
        path_buf.push(file_name.as_str());
        let file = File::create(path_buf.clone())?;
        Ok(TempFile {
            file_path: path_buf,
            file: file,
        })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        OpenOptions::new().write(true).open(&self.file_path)?.write(data)?;
        Ok(())
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        let mut buf = String::new();
        OpenOptions::new().read(true).open(&self.file_path)?.read_to_string(&mut buf)?;
        Ok(buf)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}

hafihaf123

a day ago

4.52ms

87.95kb

use std::path::PathBuf;
use std::fs::{OpenOptions, File, remove_file};
use std::io::{Read, Write, Seek};
use std::time::{SystemTime, UNIX_EPOCH, Duration};
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        // Your code here...
        // pseudo-random number for the name
        let rand = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap_or_else(|_| {
                // fallback pseudo-random number from pointers
                Duration::new(
                    0,
                    &vec![951561u32, 16520u32] as *const Vec<u32> as u32 % 10000
                )
            })
            .subsec_nanos();
        let mut file_path = std::env::temp_dir();
        file_path.push(rand.to_string());
        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)?;
        Ok(())
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        // Your code here...
        self.file.seek(std::io::SeekFrom::Start(0))?;
        let mut buffer = String::new();
        self.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).unwrap_or_else(|e| {
            if e.kind() != std::io::ErrorKind::NotFound {
                eprintln!(
                    "Unexpected error while clearing temporary file {}: {e:?}",
                    self.path().display()
                );
            }
        });
    }
}

hafihaf123

a day ago

4.34ms

87.95kb

use std::path::PathBuf;
use std::fs::{OpenOptions, File, remove_file};
use std::io::{Read, Write, Seek};
use std::time::{SystemTime, UNIX_EPOCH, Duration};
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 = PathBuf::from(std::env::temp_dir());
        // pseudo-random number for the name
        let rand = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap_or_else(|_| {
                // fallback pseudo-random number from pointers
                Duration::new(
                    0,
                    &vec![951561u32, 16520u32] as *const Vec<u32> as u32 % 10000
                )
            })
            .subsec_nanos();
        file_path.push(rand.to_string());
        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...
        self.file.seek(std::io::SeekFrom::Start(0))?;
        let mut buffer = String::new();
        self.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).unwrap_or_else(|e| {
            if e.kind() != std::io::ErrorKind::NotFound {
                eprintln!(
                    "Unexpected error while clearing temporary file {}: {e:?}",
                    self.path().display()
                );
            }
        });
    }
}

Tim Toebrock

titoeb

2 days ago

4.68ms

87.41kb

use std::fs::File;
use std::fs::OpenOptions;
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,
}
fn random_file_name() -> String {
    let start = SystemTime::now();
    let since_the_epoch = start
        .duration_since(UNIX_EPOCH)
        .expect("Time went backwards");
    let random_number = since_the_epoch.as_nanos();
    format!("{:?}", random_number)
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let file_path = std::env::temp_dir().join(random_file_name());
        let file = File::create(file_path.clone())?;
        Ok(Self { file_path, file })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        self.file.write_all(data)?;
        Ok(())
    }
    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
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let _ = std::fs::remove_file(&self.file_path);
    }
}
fn main() {}

Stefano Cianciulli

CianciuStyles

2 days ago

5.33ms

87.53kb

use std::fs::{File, OpenOptions, remove_file};
use std::path::PathBuf;
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 file_name = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap().as_nanos().to_string();
        let file_path = [std::env::temp_dir(), file_name.into()].iter().collect();
        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(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
    }
}

Claus Guttesen

kometen

2 days ago

4.41ms

87.95kb

use std::path::{Path, PathBuf};
use std::fs::{File, OpenOptions, remove_file};
use std::io::{Read, Write};
use std::time::{SystemTime, UNIX_EPOCH};
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let path = Path::new(&self.file_path);
        if path.is_file() {
            remove_file(&self.file_path).unwrap();
        }
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        // Your code here...
        let mut file_path: PathBuf = std::env::temp_dir();
        let timestamp = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_nanos();
        file_path.push(timestamp.to_string());
        let file = File::create(&file_path)?;
        let temp_file = TempFile {file_path, file};
        Ok(temp_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 content = String::new();
        file.read_to_string(&mut content)?;
        Ok(content)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}

gmvar

2 days ago

4.94ms

87.53kb

use std::path::PathBuf;
use std::fs::{File, remove_file};
use std::fs::OpenOptions;
use std::io::prelude::*;
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)?;
        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
    }
}

Guilherme Cesário Strachan

strachan

2 days ago

4.67ms

87.89kb

use std::fs::OpenOptions;
use std::path::{Path, PathBuf};
use std::fs::{self, File};
use std::time::SystemTime;
use std::io::Write;
use std::io::Read;
pub struct TempFile {
    file_path: PathBuf,
    file: File
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let path = Path::new(&self.file_path);
        if path.is_file() {
            fs::remove_file(&self.file_path).unwrap();
        }
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let file_path: PathBuf = [std::env::temp_dir(), SystemTime::now()
            .duration_since(SystemTime::UNIX_EPOCH)
            .unwrap()
            .as_nanos()
            .to_string().into()].iter().collect();
        let file: 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)?;
        let _ = 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
    }
}

Sukrit Amornpornwiwat

arm01846

2 days ago

7.31ms

87.78kb

use std::env::temp_dir;
use std::fs::File;
use std::fs::OpenOptions;
use std::path::PathBuf;
use std::io::{Write, Read};
use std::str::from_utf8;
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        // Your code here...
        let mut f = File::open("/dev/urandom").unwrap();
        let mut buf = [0u8; 16];
        f.read_exact(&mut buf)?;
        let filename = buf.iter().map(|x| {*x as u32}).sum::<u32>().to_string();
        let path = temp_dir().join(filename);
        let file = File::create(&path)?;
        Ok(TempFile {
            file_path: path,
            file: file,
        })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        OpenOptions::new().write(true).open(&self.file_path)?.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) {
        std::fs::remove_file(&self.file_path);
    }
}

Masayuki Sunahara

tamanishi

2 days ago

6.22ms

88.19kb

use std::fs;
use std::fs::{File, OpenOptions};
use std::io::{Read, Write};
use std::path::{Path, PathBuf};
use std::time::SystemTime;
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let path = Path::new(&self.file_path);
        if path.is_file() {
            fs::remove_file(&self.file_path).unwrap();
        }
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        // Your code here...
        let temp_dir = std::env::temp_dir();
        let file_name = SystemTime::now()
            .duration_since(SystemTime::UNIX_EPOCH)
            .unwrap()
            .as_nanos()
            .to_string();
        let file_path = format!("{}/{}", temp_dir.display(), file_name);
        println!("{}", file_path);
        let file = File::create(&file_path)?;
        Ok(
            TempFile {
                file_path: PathBuf::from(file_path),
                file: file,
            }
        )
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        // Your code here...
        self.file.write_all(data)?;
        self.file.flush()?;
        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
    }
}

Rocky.C

cloki0610

2 days ago

12.55ms

87.89kb

use std::fs::{File, OpenOptions};
use std::io::{Read, Write};
use std::path::PathBuf;
use std::time::{SystemTime, UNIX_EPOCH};
fn random_filename() -> String {
    let timestamp = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .expect("Time went backwards")
        .as_nanos();
    format!("temp_{}", timestamp)
}
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let mut file_path = PathBuf::new();
        file_path.push(std::env::temp_dir());
        file_path.push(random_filename());
        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(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) {
        std::fs::remove_file(&self.file_path);
    }
}

Michal Miškerník

miscer

2 days ago

7.06ms

87.86kb

use std::fs::{File, OpenOptions};
use std::io::{Read, Write};
use std::path::PathBuf;
use std::time::{SystemTime, UNIX_EPOCH};
fn random_filename() -> String {
    let timestamp = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .expect("Time went backwards")
        .as_nanos();
    format!("temp_{}", timestamp)
}
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let mut file_path = PathBuf::new();
        file_path.push(std::env::temp_dir());
        file_path.push(random_filename());
        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(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) {
        std::fs::remove_file(&self.file_path);
    }
}

Ankit Kumar Jha

Ankit8848

2 days ago

5.36ms

87.53kb

use std::path::PathBuf;
use std::fs::{File, remove_file};
use std::fs::OpenOptions;
use std::io::prelude::*;
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
    }
}

vihamaki

2 days ago

4.27ms

87.53kb

use std::path::PathBuf;
use std::fs::{File, remove_file};
use std::fs::OpenOptions;
use std::io::prelude::*;
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
    }
}

Dominic

DominicD

2 days ago

4.88ms

87.53kb

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 {
    pub file_path: PathBuf,
    pub file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let tmp_file_name = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap().as_nanos().to_string();
        let tmp_dir = temp_dir().join(&tmp_file_name);
        let file = File::create(&tmp_dir)?;
        let file = Self {
            file_path: tmp_dir,
            file: file,
        };
        Ok(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 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) {
        match remove_file(&self.file_path) { 
            Ok(_) => {},
            Err(e) => eprintln!("Error removing file. {}", e),
        }
    }
}

Frank

frankstolle

2 days ago

5.75ms

87.53kb

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 {
    pub file_path: PathBuf,
    pub file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let tmp_file_name = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap().as_nanos().to_string();
        let tmp_dir = temp_dir().join(&tmp_file_name);
        let file = File::create(&tmp_dir)?;
        let file = Self {
            file_path: tmp_dir,
            file: file,
        };
        Ok(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 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) {
        match remove_file(&self.file_path) { 
            Ok(_) => {},
            Err(e) => eprintln!("Error removing file. {}", e),
        }
    }
}

Joanne Muthoni

joanne-cmd

2 days ago

4.67ms

87.53kb

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 {
    pub file_path: PathBuf,
    pub file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let tmp_file_name = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap().as_nanos().to_string();
        let tmp_dir = temp_dir().join(&tmp_file_name);
        let file = File::create(&tmp_dir)?;
        let file = Self {
            file_path: tmp_dir,
            file: file,
        };
        Ok(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 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) {
        match remove_file(&self.file_path) { 
            Ok(_) => {},
            Err(e) => eprintln!("Error removing file. {}", e),
        }
    }
}

Rounak Sen

rony0000013

2 days ago

5.89ms

87.53kb

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 {
    pub file_path: PathBuf,
    pub file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let tmp_file_name = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap().as_nanos().to_string();
        let tmp_dir = temp_dir().join(&tmp_file_name);
        let file = File::create(&tmp_dir)?;
        let file = Self {
            file_path: tmp_dir,
            file: file,
        };
        Ok(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 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) {
        match remove_file(&self.file_path) { 
            Ok(_) => {},
            Err(e) => eprintln!("Error removing file. {}", e),
        }
    }
}

vaclav0411

2 days ago

4.54ms

87.53kb

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 {
    pub file_path: PathBuf,
    pub file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let tmp_file_name = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap().as_nanos().to_string();
        let tmp_dir = temp_dir().join(&tmp_file_name);
        let file = File::create(&tmp_dir)?;
        let file = Self {
            file_path: tmp_dir,
            file: file,
        };
        Ok(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 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) {
        match remove_file(&self.file_path) { 
            Ok(_) => {},
            Err(e) => eprintln!("Error removing file. {}", e),
        }
    }
}

Krzysztof Atłasik

katlasik

2 days ago

5.34ms

87.78kb

use std::fs::{File, OpenOptions};
use std::path::PathBuf;
use std::env;
use std::io::{Read, Write};
use std::time::{SystemTime, UNIX_EPOCH};
use std::fs::remove_file;
#[derive(Debug)]
pub struct TempFile {
    file_path: PathBuf,
    file: File
}
impl Drop for TempFile{
    fn drop(&mut self){
        remove_file(&self.file_path);
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let tmd_dir = env::temp_dir();
        let random_name = SystemTime::now()
          .duration_since(SystemTime::UNIX_EPOCH)
          .unwrap()
          .as_nanos()
          .to_string();
        let file_path = tmd_dir.join(random_name); 
        let file = File::create(&file_path)?;
        
        Ok(
            TempFile{
                file,
                file_path
            }
        )
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        OpenOptions::new().write(true).open(&self.file_path)?.write_all(data)
    }
    pub fn write_string(&mut self, data: &str) -> Result<(), std::io::Error> {
        self.write(data.as_bytes())
    }
    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
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}

Njerii

wamimi

2 days ago

4.59ms

87.58kb

use std::fs::{File, OpenOptions};
use std::io::{Read, Write};
use std::path::PathBuf;
use std::env::temp_dir;
use std::time::{SystemTime, UNIX_EPOCH};
pub struct TempFile {
    pub file_path: PathBuf,
    pub file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        // Create a unique filename using timestamp
        let timestamp = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_nanos();
        
        let file_name = format!("temp_{}", timestamp);
        let mut file_path = temp_dir();
        file_path.push(file_name);
        
        // Create the file
        let file = File::create(&file_path)?;
        
        Ok(TempFile {
            file_path,
            file,
        })
    }
    
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        // Open file in write mode
        let mut file = OpenOptions::new()
            .write(true)
            .open(&self.file_path)?;
            
        file.write_all(data)?;
        file.flush()?;
        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) {
        // Attempt to remove the file when the TempFile is dropped
        if let Err(e) = std::fs::remove_file(&self.file_path) {
            eprintln!("Failed to remove temporary file: {}", e);
        }
    }
}

Chris

chriswmann

2 days ago

6.66ms

87.53kb

use std::fs::{File, OpenOptions, remove_file};
use std::io::{Read, Write};
use std::path::PathBuf;
pub struct TempFile {
    pub file_path: PathBuf,
    pub file: File,
}
impl Drop for TempFile {
    fn drop(&mut self){
        match remove_file(&self.file_path) {
            Ok(_) => {},
            Err(e) => eprintln!("Error removing file. {}", e),
        }
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let temp_dir = std::env::temp_dir();
        let now = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .expect("We are past the Unix epoch to should get a duration since then");
        let file_path = temp_dir.join(format!("{}", now.as_nanos()));
        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(&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
    }
}

KLcpb

3 days ago

5.31ms

87.95kb

use std::path::PathBuf;
use std::fs::{OpenOptions, File};
use std::io::prelude::*;
use std::fs::remove_file;
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        // Your code here...
        let mut temp_dir = std::env::temp_dir();
        let now = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap(); // TODO: handle this better
        let file_path = temp_dir.join(format!("{}", now.as_nanos()));
        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 f = OpenOptions::new().write(true).open(&self.file_path)?;
        f.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){
        remove_file(&self.file_path);
    }
}

Will LaBranche

wlabranche

3 days ago

4.87ms

87.95kb

use std::path::PathBuf;
use std::fs::{OpenOptions, File};
use std::io::prelude::*;
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let temp_dir = std::env::temp_dir();
        let now = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap(); // TODO: handle this better
        let file_path = temp_dir.join(format!("{}", now.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 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) {
        if std::fs::remove_file(&self.file_path).is_err() {}
    }
}

Will LaBranche

wlabranche

3 days ago

4.96ms

87.97kb

use std::path::PathBuf;
use std::fs::{OpenOptions, File};
use std::io::prelude::*;
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let temp_dir = std::env::temp_dir();
        let now = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap(); // TODO: handle this better
        let file_path = temp_dir.join(format!("{}", now.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 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) {
        if std::fs::remove_file(&self.file_path).is_err() {}
    }
}

Jean-Roland Gosse

jean-roland

3 days ago

4.23ms

87.89kb

use std::fs::{remove_file, File, OpenOptions};
use std::io::{Read, 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> {
        let temp_dir = std::env::temp_dir();
        let random_number: u64 = {
            let start = SystemTime::now();
            let since_epoch = start.duration_since(UNIX_EPOCH).unwrap();
            since_epoch.as_nanos() as u64
        };
        let file_name = format!("tempfile-{}.tmp", random_number);
        let file_path = 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> {
        self.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 _ = remove_file(&self.file_path);
    }
}

Burnus

3 days ago

5.07ms

87.38kb

use std::io::prelude::*;
use std::fs::{File, OpenOptions};
use std::path::PathBuf;
pub struct TempFile {
    file: File,
    file_path: PathBuf,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let mut name = 0_usize;   
        let mut file_path = std::env::temp_dir();
        file_path.push(&name.to_string()[..]);
        let mut file = File::create_new(file_path.as_path());
        while file.is_err() {
            name += 1;
            file_path.pop();
            file_path.push(&name.to_string()[..]);
            file = File::create_new(file_path.as_path());
        }
        Ok(Self{ file: file.unwrap(), 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)?;
        Ok(())
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        let file = OpenOptions::new().read(true).open(&self.file_path)?;
        let mut buffer = String::new();
        self.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.file_path.clone());
    }
}

Tõnis Kevvai

tonisk

3 days ago

4.63ms

87.95kb

use std::{
    time::SystemTime,
    fs::{File, OpenOptions, remove_file},
    io::{Read, Write},
    path::PathBuf
};
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 = SystemTime::now()
            .duration_since(SystemTime::UNIX_EPOCH)
            .unwrap()
            .as_nanos()
            .to_string();
        file_path.push(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_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) {
        remove_file(&self.file_path).ok();
    }
}