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

Kishan Patel

KishanPatel4273

19 hours ago

5.16ms

87.96kb

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

ckab

ckab04

7 days ago

5.37ms

87.56kb

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

Trevor Kann

TrevorGKann

7 days ago

5.20ms

88.04kb

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

Christopher Nielson

c-nielson

9 days ago

5.34ms

87.56kb

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

codervijo

9 days ago

5.12ms

88.04kb

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

Leandro Abreu

leandronowras

17 days ago

4.70ms

87.57kb

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

Ido Barkan

barkanido

21 days ago

4.51ms

87.57kb

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

Artem

CaptainBloodborne

21 days ago

4.47ms

87.63kb

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

Artem

CaptainBloodborne

22 days ago

4.64ms

87.59kb

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

Kj

kj-9

23 days ago

5.90ms

87.55kb

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

gsspdev

23 days ago

4.74ms

87.97kb

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

Derek Chen-Becker

dchenbecker

24 days ago

4.68ms

87.97kb

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

Duncan Macharia

Devdannetworks

24 days ago

6.04ms

87.60kb

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

Antoine Plard

tylp

a month ago

5.73ms

87.37kb

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

Job Matheka

jobm

a month ago

4.99ms

87.86kb

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

isaaclv

a month ago

5.88ms

87.53kb

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

isaaclv

a month ago

4.63ms

87.53kb

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

Grant Kinney

creativecoder

a month ago

5.16ms

87.95kb

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

Psychloor

a month ago

5.53ms

87.96kb

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

arilet

a month ago

5.03ms

87.41kb

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

Ferdinand de Baecque

Ferdinanddb

a month ago

4.67ms

87.78kb

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

Francisco López

franlopezm

a month ago

4.52ms

87.78kb

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

Chase Walden

chasewalden

a month ago

4.44ms

87.81kb

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

Sergei Chertkov

mamont

a month ago

5.10ms

87.96kb

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

Kinuko Yasuda

kinu

a month ago

6.35ms

87.46kb

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

Kinuko Yasuda

kinu

a month ago

4.50ms

87.46kb

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

Tengz Mao

MaoX-Yu

a month ago

4.88ms

87.98kb

use std::path::PathBuf;
use std::fs::{self, File, OpenOptions};
use std::env;
use std::time::{SystemTime, UNIX_EPOCH};
use std::io::prelude::*;
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 = env::temp_dir();
        let now = SystemTime::now();
        let time = now.duration_since(UNIX_EPOCH).unwrap().as_nanos();
        file_path.push(format!("{}", time));
        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 buf = String::new();
        file.read_to_string(&mut buf)?;
        Ok(buf)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        if let Err(e) = fs::remove_file(&self.file_path) {
            eprintln!("{}", e)
        }
    }
}

GoT

PierreRambaud

a month ago

5.51ms

87.55kb

use std::env::temp_dir;
use std::path::PathBuf;
use std::fs::{File, OpenOptions, remove_file};
use std::time::{SystemTime, UNIX_EPOCH};
use std::io::{Read, Write};
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 start = SystemTime::now();
        let now = start.duration_since(UNIX_EPOCH).unwrap().as_nanos();
        file_path.push(format!{"temp_{}",now});
        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> {
        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 let Err(e) = remove_file(&self.file_path) {
            eprintln!("Error while removing file: {}", e);
        }
    }
}

TorunR

a month ago

5.46ms

87.96kb

use std::path::PathBuf;
use std::fs::OpenOptions;
use std::fs::File;
use std::io::Read;
use std::io::Write;
use std::time::SystemTime;
use std::time::UNIX_EPOCH;
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 start = SystemTime::now();
        let now = start
        .duration_since(UNIX_EPOCH).unwrap().as_nanos();
        path.push(format!{"temp_{}",now});
        let file = File::create(&path)?;
        Ok(TempFile {
            file_path: 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)
    }
    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
    }
}
use std::fs;
impl Drop for TempFile {
    fn drop(&mut self) {
        std::fs::remove_file(&self.file_path);
    }
}

idiel

a month ago

10.16ms

87.43kb

use std::fs::{File, OpenOptions, remove_file};
use std::path::PathBuf;
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 generate_filename(length: usize) -> String {
        const CHARSET: &[u8] = b"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
    
        // Get current time as nanoseconds
        let nanos = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_nanos();
        
        let mut result = String::with_capacity(length);
        
        for i in 0..length {
            // Use different bits of nanos for each position
            let idx = ((nanos >> (i * 4)) & 0x3f) as usize % CHARSET.len();
            result.push(CHARSET[idx] as char);
        }
        
        result
    }
    pub fn new() -> Result<Self, std::io::Error> {
        // Your code here...
        let temp_dir = std::env::temp_dir();
        let temp_path = temp_dir.join(TempFile::generate_filename(16));
        Ok(TempFile {file_path: temp_path.clone(), file: File::create(&temp_path)?})
    }
    pub fn write(&mut self, data: &[u8]) -> Result<(), std::io::Error> {
        // Your code here...
        let mut file = OpenOptions::new().write(true).open(&self.file_path)?;
        file.write_all(data)?;
        Ok(())
    }
    pub fn read_to_string(&mut self) -> Result<String, std::io::Error> {
        // Your code here...
        let mut file = OpenOptions::new().read(true).open(&self.file_path)?;
        let mut buffer = String::new();
        file.read_to_string(&mut buffer)?;
        Ok(buffer)
    }
    pub fn path(&self) -> &PathBuf {
        &self.file_path
    }
    pub fn file(&self) -> &File {
        &self.file
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let _ = remove_file(self.file_path.clone());
    }
}

stanisgo

a month ago

4.41ms

87.89kb

use std::fs::{File, OpenOptions, remove_file};
use std::io::{Read, Write};
use std::path::PathBuf;
use std::time::{SystemTime, UNIX_EPOCH};
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 temp_dir = std::env::temp_dir();
        let temp_number = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_nanos();
        let temp_filename = format!("tempfile-{}.tmp", temp_number);
        let file_path = temp_dir.join(temp_filename);
        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
    }
}

Nikita Smirnov

Nismirno

a month ago

4.66ms

87.95kb

use std::time::{UNIX_EPOCH, SystemTime};
use std::path::PathBuf;
use std::fs::{File, OpenOptions};
use std::io::prelude::*;
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 unix_duration = SystemTime::now().duration_since(UNIX_EPOCH).expect("err");
        let file_name = unix_duration.as_nanos().to_string();
        file_path.push(file_name.as_str());
        let file = match File::create(&file_path) {
            Ok(f) => f,
            Err(e) => return Err(e),
        };
        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 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) {
        let _ = std::fs::remove_file(&self.file_path);
    } 
}

joshvon44

a month 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

a month 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

a month 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

a month 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

a month 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

a month 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

a month 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

a month 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

a month 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

a month 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

a month 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

a month 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

a month 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

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

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

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

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

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