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

Zodiacsyndicate

ZodiacSyndicate

2 days ago

8.07ms

95.61kb

use std::fs::File;
use std::path::PathBuf;
use std::io::{Seek, Read, Write};
use std::time::Instant;
use std::hash::{Hash, Hasher, DefaultHasher};
pub struct TempFile {
    file: File,
    file_path: PathBuf,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let mut hasher = DefaultHasher::new();
        Instant::now().hash(&mut hasher);
        let file_path = PathBuf::from(format!("/tmp/{:X}.tmp", hasher.finish()));
        let file = File::create_new(&file_path)?;
        Ok(Self { file, file_path, })
    }
    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 buf_reader = std::io::BufReader::new(&self.file);
        let mut contents = String::new();
        buf_reader.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 _ = std::fs::remove_file(&self.file_path);
    }
}

Pavloslav

pavloslav

4 days ago

8.30ms

95.61kb

use std::fs::File;
use std::path::PathBuf;
use std::io::{Seek, Read, Write};
use std::time::Instant;
use std::hash::{Hash, Hasher, DefaultHasher};
pub struct TempFile {
    file: File,
    file_path: PathBuf,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let mut hasher = DefaultHasher::new();
        Instant::now().hash(&mut hasher);
        let file_path = PathBuf::from(format!("/tmp/{:X}.tmp", hasher.finish()));
        let file = File::create_new(&file_path)?;
        Ok(Self { file, file_path, })
    }
    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 buf_reader = std::io::BufReader::new(&self.file);
        let mut contents = String::new();
        buf_reader.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 _ = std::fs::remove_file(&self.file_path);
    }
}

MiikkaVG

5 days ago

10.94ms

87.45kb

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

varghamarci

5 days ago

9.65ms

87.46kb

use std::{
    env::temp_dir,
    fs::{File, OpenOptions, remove_file},
    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 mut path = temp_dir();
        let rndm = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_nanos();
        path.push(format!("tmpfile_{}", rndm));
        let file = File::create(&path)?;
        Ok(TempFile {
            file_path: 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> {
        let mut file_to_read = OpenOptions::new().read(true).open(&self.file_path)?;
        let mut buffer = String::new();
        file_to_read.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.clone());
    }
}

nataziel

8 days ago

6.89ms

88.15kb

use std::{
    env::temp_dir,
    fs::{File, OpenOptions, remove_file},
    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 mut file_path = temp_dir();
        let file_name = format!(
            "temp_{}",
            SystemTime::now()
                .duration_since(UNIX_EPOCH)
                .unwrap()
                .as_nanos()
        );
        file_path.push(file_name);
        println!("{file_path:?}");
        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_to_read = OpenOptions::new().read(true).open(&self.file_path)?;
        let mut contents = String::new();
        file_to_read.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) {
        remove_file(self.file_path.clone());
    }
}

Eugene Korir

korir248

10 days ago

6.17ms

88.42kb

use std::{
    fs::{File, OpenOptions},
    io::{Read, Write},
    path::PathBuf,
};
pub struct TempFile {
    file: File,
    file_path: PathBuf,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let file_name = format!(
            "temp_{}",
            std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap()
                .as_nanos()
        );
        let mut file_path = std::env::temp_dir();
        file_path.push(&file_name);
        let file =
            File::create(&file_path).inspect_err(|e| println!("Could not create file, {}", e))?;
        Ok(Self { file_path, file })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        let mut file = OpenOptions::new().append(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 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) {
        println!("Deleting temp file: {:?}", self.file_path);
        let _ = std::fs::remove_file(&self.file_path)
            .inspect_err(|e| println!("Error deleting file: {}", e));
    }
}
pub fn main() {
    let temp_file = TempFile::new().unwrap();
    println!("Temp file created at: {:?}", temp_file.path());
}

Atanas Krondev

AtanasKrondev

17 days ago

6.58ms

87.81kb

use std::{
    fs::{File, OpenOptions},
    io::{Read, Write},
    path::PathBuf,
};
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let file_name = format!(
            "temp_{}",
            std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap()
                .as_nanos()
        );
        let file_path = PathBuf::from("/tmp").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_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 _ = std::fs::remove_file(&self.file_path);
    }
}

Anti Räis

antirais

22 days ago

6.19ms

87.42kb

use std::path::PathBuf;
use std::fs::File;
use std::fs::OpenOptions;
use std::fs::read_to_string;
use std::fs::remove_file;
use std::io::Write;
use std::time::SystemTime;
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let _ = remove_file(&self.file_path);
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let duration = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap();
        let timestamp = duration.as_nanos();
        
        let file_path = PathBuf::from(format!("/tmp/{}.txt", timestamp));
        let file = File::create(&file_path)?;
        
        Ok(Self {
            file_path,
            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> {
        Ok(read_to_string(&self.file_path)?)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}

René Lajvort

Renkee

a month ago

4.70ms

87.44kb

use std::path::PathBuf;
use std::fs::{File, OpenOptions};
use std::io::{Write, Read};
use std::time::SystemTime;
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl Drop for TempFile {
    fn drop(&mut self) {
        if self.file_path.exists() {
            std::fs::remove_file(&self.file_path).unwrap();
        }
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let duration_since_epoch = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap();
        let timestamp_nanos = duration_since_epoch.as_nanos();
        let unique_name = format!("file{}", timestamp_nanos);
        let file_path = format!("{}/{}",std::env::temp_dir().display(), unique_name);
        Ok(TempFile {
            file_path: (&file_path).into(),
            file: File::create(&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 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
    }
}

Asrul Firdaus

AsrulF

2 months ago

4.63ms

87.56kb

use std::{env::temp_dir, fs::{remove_file, File, OpenOptions}, io::{Read, Write}, path::PathBuf, sync::atomic::{AtomicUsize, Ordering}, time::{SystemTime, UNIX_EPOCH}};
static COUNTER: AtomicUsize = AtomicUsize::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 path = temp_dir();
        let nanos= SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_nanos();
        let count = COUNTER.fetch_add(1, Ordering::Relaxed);
        let filename = format!("tempfile_{}_{}", nanos, count);
        path.push(filename);
        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...
        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) {
        if let Err(e) = remove_file(&self.file_path) {
            eprintln!("File cannot be deleted, {}", e);
        }
    }
}

Dave Weston

dtweston

2 months ago

4.56ms

87.54kb

use std::fs::{File,OpenOptions};
use std::io::{Read,Seek,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) {
        let _ = std::fs::remove_file(self.path());
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let file_path = std::env::temp_dir()
            .join(format!("{:?}", SystemTime::now()));
        let file = OpenOptions::new()
            .write(true)
            .read(true)
            .create(true)
            .open(&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> {
        self.file.rewind()?;
        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
    }
}

Ramon Silva

rsilva1

2 months ago

4.42ms

88.03kb

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 {
    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, "Can't generate random filename"))?;
        file_path.set_file_name(format!("blitzen-rocks-{}", now.as_nanos()));
        let file = File::create(&file_path)?;
        Ok(TempFile {
            file_path: file_path.into(),
            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 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);
    }
}

Volodymyr Koreniev

vkorenev

2 months ago

5.11ms

87.38kb

use std::fs::File;
use std::io::{ Read, Seek, Write };
use std::path::PathBuf;
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        // Your code here...
        let dir = std::env::temp_dir();
        let temp_file = (1..).find_map(|i| {
            let mut file_path = dir.join(i.to_string());
            file_path.set_extension("tmp");
            File::create_new(&file_path).ok().map(|file| TempFile { file_path, file })
        }).unwrap();
        Ok(temp_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.rewind()?;
        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
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        std::fs::remove_file(&self.file_path);
    }
}

Octave

BadyJoke

2 months ago

5.19ms

87.67kb

use std::path::PathBuf;
use std::fs::{File, OpenOptions};
use std::io::{Write, Read};
use std::ops::Drop;
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl Drop for TempFile {
    fn drop(&mut self) {
        if let Err(error) = std::fs::remove_file(&self.file_path) {
            println!(
                "Could not delete the file: {} ({})", 
                self.file_path.display(), 
                error
            );
        }
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let mut file_path = std::env::temp_dir();
        file_path.push(format!("{:?}", std::time::SystemTime::now()));
        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
    }
}

LiveForLife

maplestarplayl

2 months ago

10.45ms

87.36kb

use std::path::PathBuf;
use std::fs::File;
use std::io::Write;
use std::io::Read;
use std::sync::atomic::AtomicU32;
use std::sync::atomic::Ordering;
static COUNTER: AtomicU32 = AtomicU32::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 file_path = std::env::temp_dir();
        file_path.push(format!("{}", COUNTER.fetch_add(1, Ordering::Relaxed)));
        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...
        self.file.write_all(data)?;
        Ok(())
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        // Your code here...
        Ok(std::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) {
        if self.file_path.exists() {
            std::fs::remove_file(&self.file_path).unwrap();
        }
    }
}

jfloresremar

3 months ago

5.47ms

88.38kb

use std::{
    fs::{File, remove_file},
    io::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 timestamp = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .map_err(|_| std::io::ErrorKind::Other)?
            .as_nanos();
        let random_name = format!("{:x}", timestamp);
        // let mut file_path = PathBuf::new();
        let mut file_path = std::env::temp_dir();
        // file_path.push("/tmp");
        file_path.push(random_name);
        println!("{:?}", file_path);
        // if let Some(parent_dir) = file_path.parent() {
        //     // Create parent directories if they don't exist
        //     std::fs::create_dir_all(parent_dir)?;
        // }
        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> {
        std::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) {
        if self.file_path.exists() {
            match remove_file(&self.file_path) {
                Ok(_) => println!("Deleted temporary file: {}", self.file_path.display()),
                Err(e) => eprintln!("Error deleting file {}: {}", self.file_path.display(), e),
            }
        }
    }
}

Elspaddy

3 months ago

4.47ms

87.36kb

use std::io::Write;
use std::sync::atomic::{AtomicU16, Ordering};
pub struct TempFile {
    file_path: std::path::PathBuf,
    file: std::fs::File,
}
static ID_CTR : AtomicU16 = AtomicU16::new(0);
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let mut file_path = std::env::temp_dir();
        file_path.push(format!("{}", ID_CTR.fetch_add(1, Ordering::Relaxed)));
        let file = std::fs::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> {
        Ok(std::fs::read_to_string(&self.file_path)?)
    }
    pub fn path(&self) -> &std::path::PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &std::fs::File {
        &self.file
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        if self.file_path.exists() {
            std::fs::remove_file(&self.file_path).unwrap();
        }
    }
}

Alex Conley

aconley

3 months ago

5.20ms

87.36kb

use std::io::Write;
use std::sync::atomic::{AtomicU16, Ordering};
pub struct TempFile {
    file_path: std::path::PathBuf,
    file: std::fs::File,
}
static ID_CTR : AtomicU16 = AtomicU16::new(0);
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let mut file_path = std::env::temp_dir();
        file_path.push(format!("{}", ID_CTR.fetch_add(1, Ordering::Relaxed)));
        let file = std::fs::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> {
        // Your code here...
        Ok(std::fs::read_to_string(&self.file_path)?)
    }
    pub fn path(&self) -> &std::path::PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &std::fs::File {
        &self.file
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        // The file may have been removed by external action.
        if self.file_path.exists() {
            std::fs::remove_file(&self.file_path).unwrap();
        }
    }
}

TheJanzap

3 months ago

5.48ms

87.54kb

use std::{env, fs};
use std::fs::File;
use std::path::PathBuf;
use std::io::Write;
use std::time::SystemTime;
pub struct TempFile {
    pub file_path: PathBuf,
    pub file: File
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        // Your code here...
        let time = SystemTime::now();
        let path = env::temp_dir().join(format!("{time:?}"));
        let file = File::create(&path)?;
        Ok(Self{file_path: path, file: 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...
        Ok(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) {
        if !self.file_path.exists() {return;}
        fs::remove_file(&self.file_path).unwrap();
    }
}

Marcin

panpilkarz

3 months ago

10.20ms

87.53kb


use std::{
    fs::{self, File},
    path::PathBuf,
    time::SystemTime,
};
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let file_path = std::env::temp_dir().join(format!("{:?}", SystemTime::now()));
        let file = fs::File::create_new(&file_path)?;
        Ok(Self { file_path, file })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        fs::write(self.path(), data)
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        fs::read_to_string(self.path())
    }
    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.path());
    }
}

Splatrac

splatrac

3 months ago

5.33ms

87.53kb

use std::path::PathBuf;
use std::fs::{File, OpenOptions, remove_file};
use std::io::prelude::*;
use std::time::SystemTime;
pub struct TempFile {
    file_path: PathBuf,
    file: File
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let _ = remove_file(&self.path());
    }
} 
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        // Your code here...
        let now = SystemTime::now();
        let mut file_path = std::env::temp_dir();
        file_path.push(format!("{now:?}"));
        let f = File::create(&file_path)?;
        Ok(Self { file_path: file_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.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
    }
}

Prashant Puri

Prashant-dot1

4 months ago

5.03ms

87.48kb

use std::{fs::File, io::{Read, Write, Seek, SeekFrom}, path::PathBuf, time};
pub struct TempFile {
    file_path : PathBuf,
    file: File
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        // Create a unique temporary file name using process ID and current time
        let file_name = format!("temp_file_{}_{}.txt", 
            std::process::id(), 
            time::SystemTime::now()
                .duration_since(time::UNIX_EPOCH)
                .unwrap_or_default()
                .as_nanos());
        let file = File::create_new(format!("/tmp/{}", file_name))?;
        Ok(TempFile { file_path: PathBuf::from(format!("/tmp/{}", file_name)), file })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        // Write data and flush to ensure it's written to disk
        self.file.write_all(data)?;
        self.file.flush()?;
        Ok(())
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        // Seek to the beginning of the file to read from start
        self.file.seek(SeekFrom::Start(0))?;
        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) {
        // Clean up the temporary file when the TempFile is dropped
        if self.file_path.exists() {
            let _ = std::fs::remove_file(&self.file_path);
        }
    }
}

Heino Mortensen

hmortensen83

4 months ago

6.58ms

87.54kb

use std::{
    fs::{self, File},
    path::PathBuf,
    time::SystemTime,
};
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let file_path = std::env::temp_dir().join(format!("{:?}", SystemTime::now()));
        let file = fs::File::create_new(&file_path)?;
        Ok(Self { file_path, file })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        fs::write(self.path(), data)
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        fs::read_to_string(self.path())
    }
    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.path());
    }
}

Andreas Lundin

andreaslundin47

4 months ago

5.42ms

87.94kb

use std::fs::{File, OpenOptions};
use std::io::{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_path: PathBuf = 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!("temp-{}", random_number);
        let file_path = temp_dir_path.join(file_name);
        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)
    }
    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 _ = std::fs::remove_file(&self.file_path);
    }
}

Spheniscine

5 months ago

6.23ms

87.97kb

use std::{fs::{File, OpenOptions}, hash::{BuildHasher, Hasher, RandomState}, io::{Read, Write}, path::PathBuf};
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
fn rand_u64() -> u64 {
    let state = RandomState::new();
    let hasher = state.build_hasher();
    hasher.finish()
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let mut buf = std::env::temp_dir();
        let name = format!("jingle_{}.tmp", rand_u64());
        buf.push(name);
        let file = File::create(&buf)?;
        Ok(TempFile {
            file_path: buf,
            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)
    }
    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 _ = std::fs::remove_file(self.path());
    }
}

palcoo42

5 months ago

4.69ms

87.51kb

use std::{
    fs::File,
    io::{Read, Seek, Write},
    path::PathBuf,
    time::UNIX_EPOCH,
};
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let current_time_ms = std::time::SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .map_err(|_err| std::io::ErrorKind::Other)?
            .as_micros();
        let file_name = format!("{current_time_ms}.tmp");
        let mut file_path = std::env::temp_dir();
        file_path.push(file_name);
        let file = File::create_new(file_path.clone())?;
        Ok(Self { file_path, file })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        let _size = self.file.write(data)?;
        Ok(())
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        self.file.rewind()?;
        let mut buf = String::with_capacity(128);
        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) {
        let _result = std::fs::remove_file(&self.file_path);
    }
}

visanr

5 months ago

4.44ms

87.53kb

use std::path::PathBuf;
use std::fs::{File, OpenOptions};
use std::io::{Read, Write};
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 mut path = std::env::temp_dir();
        let now = SystemTime::now();
        path.push(format!("{now:?}"));
        let file = File::create(&path)?;
        Ok(Self {
            file_path: 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 _ = std::fs::remove_file(&self.file_path);
    }
}

visanr

5 months ago

6.05ms

87.56kb

use std::path::PathBuf;
use std::fs::{File, OpenOptions};
use std::io::{Read, Write};
use std::time::SystemTime;
fn random_temp_path() -> std::path::PathBuf {
    let mut path = std::env::temp_dir();
    let now = SystemTime::now();
    path.push(format!("{now:?}"));
    path
}
pub struct TempFile {
    pub file_path: PathBuf,
    pub file: File
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let path = random_temp_path();
        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
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        if let Err(e) = std::fs::remove_file(&self.file_path) {
            println!("Removing file from fs failed: {}", e);
        }
    }
}

angalar

5 months ago

5.14ms

87.53kb

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();
        let now = SystemTime::now();
        file_path.push(format!("{now:?}"));
        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)?;
        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 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
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let _ = std::fs::remove_file(&self.file_path);
    }
}

gustavLindqvist

5 months ago

4.86ms

87.53kb

use std::fs::{remove_file, File, OpenOptions};
use std::io::{Error, 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();
        let now = SystemTime::now();
        file_path.push(format!("{now:?}"));
        let file = File::create(&file_path)?;
        Ok(TempFile {
            file_path,
            file,
        })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), Error> {
        self.file.write_all(data)
    }
    pub fn read_to_string(&mut self) -> Result<String, 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);
    }
}

Wouter

WouterMartens

5 months ago

5.95ms

87.53kb

use std::fs::{remove_file, File, OpenOptions};
use std::io::{Error, 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();
        let now = SystemTime::now();
        file_path.push(format!("{now:?}"));
        let file = File::create(&file_path)?;
        Ok(TempFile {
            file_path,
            file,
        })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), Error> {
        self.file.write_all(data)
    }
    pub fn read_to_string(&mut self) -> Result<String, 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);
    }
}

johndoe30bc

5 months ago

5.27ms

88.65kb

use std::{
    fs::File,
    io::{Read, Write},
    path::PathBuf,
};
pub struct TempFile {
    pub file_path: PathBuf,
    pub file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let fname = Self::create_temp_file_name("temp")?;
        let file = File::create(&fname)?;
        Ok(Self {
            file_path: fname,
            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 reader = File::open(&self.file_path)?;
        let file_len = reader.metadata()?.len();
        let mut buf = String::with_capacity(file_len as usize);
        reader.read_to_string(&mut buf)?;
        Ok(buf)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
    fn create_temp_file_name(prefix: &str) -> Result<PathBuf, std::io::Error> {
        let tmp = std::env::temp_dir();
        for attempt in 0..10_000 {
            let fname = tmp.join(format!("{prefix}{attempt:04}"));
            if !fname.exists() {
                return Ok(fname);
            }
        }
        Err(std::io::Error::other("no room for temp name"))
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        dbg!(&self.file_path);
        if let Err(e) = std::fs::remove_file(&self.file_path) {
            eprintln!("ERROR: fail to remove temp file {e}");
        }
    }
}

tdoan

5 months ago

4.49ms

87.53kb

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> {
        let mut path = std::env::temp_dir();
        let time = SystemTime::now();
        path.push(format!("{time:?}"));
        let file = File::create(&path)?;
        Ok(TempFile {
            file_path: 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> {
        let mut file = OpenOptions::new().read(true).open(&self.file_path)?;
        let mut s = String::new();
        file.read_to_string(&mut s)?;
        Ok(s)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        // self.file.close();
        let _ = std::fs::remove_file(&self.file_path);
    }
}
fn main() {}

Chloe

chloecat34

5 months ago

4.38ms

87.38kb

use std::fs;
use std::fs::File;
use std::fs::OpenOptions;
use std::io::prelude::*;
use std::io::Write;
use std::path::PathBuf;
pub struct TempFile {
    file_path: PathBuf,
    file: File
}
// I hate this, but I can't figure out how to get the rand crate on here
static mut COUNTER: usize = 0;
// This must be single threaded
fn get_counter() -> usize {
    unsafe {
        COUNTER += 1;
        COUNTER
    }
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let mut file_path = std::env::temp_dir();
        let current_val = get_counter();
        let filename = format!("tmp{}.txt", current_val);
        file_path.push(filename);
        // idk how to add external crates on here
        let file = File::create(&file_path)?;
        Ok(TempFile {
            file_path: file_path.into(),
            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 string = String::new();
        let mut file = OpenOptions::new().read(true).open(&self.file_path)?;
        file.read_to_string(&mut string)?;
        Ok(string)
    }
    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);
    }
}
// test

brucecox01

5 months ago

4.83ms

88.08kb

use std::path::PathBuf;
use std::fs::File;
use std::time::SystemTime;
use std::io::Read;
use std::io::Write;
use std::fs::OpenOptions;
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 time = SystemTime::now();
        // Your code here...
        let mut file_path = std::env::temp_dir();
        file_path.push(format!("xyz-temp-{:?}", time));
        file_path.set_extension("tmp");
        let file = File::create(file_path.clone())?;
        Ok(TempFile { 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)?;
        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
    }
}

Philippe Massicotte

PMassicotte

5 months ago

4.38ms

87.54kb

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

UncleScientist

6 months ago

4.58ms

87.99kb

use std::io::{Read, Write};
use std::{fs::File, path::PathBuf};
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let base_path = PathBuf::from("/tmp");
        let mut number = 0;
        let (file_path, file) = loop {
            let next_path = base_path.join(format!("random_name.{number}"));
            if let Ok(file) = File::create_new(&next_path) {
                break (next_path, file);
            }
            number += 1;
        };
        Ok(Self { file_path, file })
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        let _ = self.file.write(data)?;
        Ok(())
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        let mut result = String::new();
        let mut file = File::open(&self.file_path)?;
        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 _ = std::fs::remove_file(&self.file_path);
    }
}

AncientSecrets

6 months ago

4.47ms

87.98kb

use std::fs::File;
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();
        let t = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH)
        .map_err(|_| std::io::Error::other("oh no!"))?;
        file_path.push(format!("{}", t.as_micros()));
        Ok(Self {
            file: File::create(file_path.clone())?,
            file_path,
        })
    }
    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 result = String::new();
        let mut f = File::open(self.file_path.clone())?;
        f.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 _ = std::fs::remove_file(self.file_path.clone());
    }
}

HubertBL47

6 months ago

4.43ms

87.78kb

use std::{
    fs::{self, File},
    io::{Read, Write},
    path::PathBuf,
    ptr::write,
    time,
};
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        let tmp_dir = std::env::temp_dir();
        // random named file
        let tmp_file = tmp_dir.join(
            time::SystemTime::now()
                .duration_since(time::UNIX_EPOCH)
                .unwrap_or(time::Instant::now().elapsed())
                .as_nanos()
                .to_string(),
        );
        let file = File::create(&tmp_file)?;
        Ok(TempFile {
            file_path: tmp_file,
            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(data).map(|_| ())
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        let mut s = String::new();
        let mut file = fs::OpenOptions::new().read(true).open(&self.file_path)?;
        file.read_to_string(&mut s)?;
        Ok(s)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        if self.file_path.exists() {
            fs::remove_file(&self.file_path).expect("Failed to remove temp file");
        }
    }
}

Kristupas Arifovas

Quikmove

6 months ago

4.52ms

87.95kb

use std::path::PathBuf;
use std::fs::File;
use std::io::Write;
use std::io::Read;
use std::fs::OpenOptions;
use std::time;
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!("tmp_{}", time::SystemTime::now().duration_since(time::UNIX_EPOCH)
        .unwrap_or(time::Instant::now().elapsed())
        .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(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) {
        std::fs::remove_file(&self.file_path);
    }
}

xian ma

xanvcs

6 months ago

5.54ms

87.95kb

use std::fs::{File, OpenOptions, remove_file};
use std::path::PathBuf;
use std::io::{Read, Write};
use std::time::{SystemTime, UNIX_EPOCH};
use std::env::temp_dir;
pub struct TempFile {
    file_path: PathBuf,
    file: File,
}
impl TempFile {
    pub fn new() -> Result<Self, std::io::Error> {
        // Your code here...
        let time = SystemTime::now()
                .duration_since(UNIX_EPOCH)
                .expect("time since unix epoch")
                .as_nanos();
        let file_path = temp_dir().join(format!("{}", time));
        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> {
        // Your code here...
        OpenOptions::new()
            .write(true)
            .open(&self.file_path)?
            .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) {
        _ = remove_file(&self.file_path);
    }
}

zeitnut

6 months 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 months 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

6 months 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

6 months 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

7 months 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

7 months 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

7 months 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

7 months 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

7 months 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);
    }
}