The Drop Trait

The Drop trait in Rust is used to run custom cleanup logic when a value goes out of scope. This is particularly useful for managing resources like files, network connections, or any other system resources that need to be explicitly released.

When a value that implements Drop goes out of scope, the Rust runtime automatically calls the drop method, allowing you to define custom behavior for resource cleanup.

In this challenge, you will implement a struct that represents a temporary file. The file should be automatically deleted when the struct is dropped, simulating the behavior of temporary files in real-world applications.

Your Task

Create TempFile struct with a method new that takes a file name as input, it must accept both &str and String types.
Implement the Drop trait for TempFile to delete the file automatically when the struct goes out of scope.

Hints

If you're stuck, here are some hints to help you solve the challenge:

Click here to reveal hints

Use std::fs::File to create a temporary file.
Use std::env::temp_dir() to get the path for temporary files.
The std::fs::remove_file method can be used to delete files.
The PathBuf struct is helpful for managing file paths.
Use the AsRef<str> trait to allow flexible input types for the file name.
Implement the Drop trait for custom cleanup logic.

Editor not available on Mobile!

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

Solutions

StevenCanDrink

2 days ago

3.54ms

87.40kb

use std::{ fs::{ remove_file, File }, path::PathBuf };
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    // 1. Define the `new` associated function
    pub fn new<P: Into<PathBuf>>(x: P) -> Result<Self, std::io::Error> {
        let path_buf = x.into();
        let _ = File::create(&path_buf)?;
        Ok(Self { path: path_buf })
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        // Your code here to delete the file when TempFile is dropped
        if self.path.exists() {
            let _ = remove_file(&self.path);
        }
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile = TempFile::new(file_path.to_str().unwrap()).expect(
        "Failed to create temporary file"
    );
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp")).expect(
        "Failed to create temporary file"
    );
    drop(tempfile_2);
}

StevenCanDrink

2 days ago

3.86ms

87.40kb

use std::{ fs::File, path::PathBuf };
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    // 1. Define the `new` associated function
    pub fn new<P: Into<PathBuf>>(path: P) -> std::io::Result<Self> {
        let path_buf = path.into();
        // Create the file immediately
        File::create(&path_buf)?;
        Ok(Self { path: path_buf })
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        // Delete the file when TempFile is dropped
        if self.path.exists() {
            let _ = std::fs::remove_file(&self.path);
        }
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile = TempFile::new(file_path.to_str().unwrap()).expect(
        "Failed to create temporary file"
    );
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp")).expect(
        "Failed to create temporary file"
    );
    drop(tempfile_2);
}

Chih Ying Yen

xavierforge

3 days ago

3.91ms

87.41kb

use std::path::PathBuf;
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    // 1. Define the `new` associated function
    pub fn new(file_name: impl AsRef<str>) -> Result<TempFile, std::io::Error> {
        let mut temp_dir = std::env::temp_dir();
        temp_dir.push(file_name.as_ref());
        std::fs::File::create(&temp_dir)?;
        Ok(TempFile { path: temp_dir })
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        // Your code here to delete the file when TempFile is dropped
        std::fs::remove_file(&self.path);
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

amdfxlucas

5 days ago

3.96ms

87.87kb

use std::path::PathBuf;
pub struct TempFile {
    file: std::fs::File,
    pub path: PathBuf,
}
impl TempFile {
  pub fn new<T: AsRef<str>>( fname: T) -> Result<Self,String>
  {
    //let full_path =  format!("{}/{}",std::env::temp_dir().to_str().unwrap(), fname.as_ref() );
    let full_path = std::env::temp_dir().join(fname.as_ref());
    println!("new: {}", &full_path.to_str().unwrap());
    match std::fs::File::create( &full_path) 
    {Ok(f) =>
       Ok(Self{path: full_path, // PathBuf::from(fname.as_ref()),
        file: f
        }),
    Err(e) => 
        { println!("{}",e);
        Err("Failed to open file.".to_string())
        }
    }
  }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        // let full_path = format!("{}/{}", std::env::temp_dir().to_str().unwrap(), self.path.to_str().unwrap() );
        let full_path = self.path.to_str().unwrap();
        println!("drop: {}", full_path);
      std::fs::remove_file( full_path  );// .expect( format!("drop failed: {}", full_path).as_str() );
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

undefeated_

boyboi86

7 days ago

4.62ms

87.42kb

use std::{path::PathBuf,
          io::Error,
          fs::{File, 
               remove_file}, 
          env::temp_dir};
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    // 1. Define the `new` associated function
    pub fn new(path: impl AsRef<str>) -> Result<Self, Error> {
        let temp_file = Self {
            path: temp_dir().join(path.as_ref())
        };
        File::create(&temp_file.path)?;
        Ok(temp_file)
    }
    /* //Alter solution where path is created before the tempfile is created
    pub fn new(path: impl AsRef<str>) -> Result<Self, Error> {
        let path = temp_dir().join(path.as_ref());
        File::create(&path)?;
        Ok(Self {path})
        }
    */
    
}
impl Drop for TempFile {
    fn drop(&mut self) {
        // Your code here to delete the file when TempFile is dropped
        remove_file(&self.path).ok();
        
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

toto

11 days ago

4.39ms

87.42kb

use std::{
    env::temp_dir,
    fs::{remove_file, File},
    io::Error,
    path::PathBuf,
};
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    // 1. Define the `new` associated function
    pub fn new(path: impl AsRef<str>) -> Result<Self, Error> {
        let temp_file = Self {
            path: temp_dir().join(path.as_ref()),
        };
        File::create(&temp_file.path)?;
        Ok(temp_file)
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        // Your code here to delete the file when TempFile is dropped
        remove_file(&self.path).ok();
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

GunGraveCpp

11 days ago

3.95ms

87.43kb

use std::{fs::File, path::PathBuf};
// use std::fs::File;
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    pub fn new(path: &str) -> Result<TempFile, ()>{
        let path =  PathBuf::from(path);
        match File::create(&path) {
            Ok(_) => return Ok(TempFile{path: PathBuf::from(&path)}),
            Err(_) => return Err(())
        }
    }  
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let _ =std::fs::remove_file(&self.path);
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

aghia98

12 days ago

3.76ms

87.43kb

use std::path::PathBuf;
use std::fs::File;
use std::fs;
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    // 1. Define the `new` associated function
    pub fn new(name: impl AsRef<str>) -> Result<Self, std::io::Error> {
        let path = PathBuf::from(name.as_ref());
        File::create(path.clone())?;
        Ok(Self {
            path
        })
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        // Your code here to delete the file when TempFile is dropped
        fs::remove_file(self.path.clone());
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

manu3618

13 days ago

4.09ms

87.43kb

use std::path::PathBuf;
use std::fs::File;
use std::fs;
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    // 1. Define the `new` associated function
    pub fn new<T: AsRef<str>>(name: T) -> Result<Self, String> {
        let path = PathBuf::from(name.as_ref());
        match File::create(path.clone()) {
            Ok(_) => Ok(Self { path }),
            _ => Err("Failed to create temporary file".into())
        }
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        // Your code here to delete the file when TempFile is dropped
        let _ = fs::remove_file(self.path.clone());
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

Lvfalue

14 days ago

3.96ms

87.40kb

use std::path::PathBuf;
use std::fs::{File, remove_file};
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    // 1. Define the `new` associated function
    pub fn new(file_name: impl AsRef<str>) -> std::io::Result<Self> {
        File::create(file_name.as_ref())?;
        Ok(TempFile {
            path: PathBuf::from(file_name.as_ref())
        })
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        // Your code here to delete the file when TempFile is dropped
        let _ = remove_file(&self.path);
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

visanr

17 days ago

4.51ms

87.40kb

use std::path::PathBuf;
pub struct TempFile {
    pub path: PathBuf,
}
use std::fs::File;
use std::io::Error;
impl TempFile {
    pub fn new<T: AsRef<str>>(file_path: T) -> Result<Self, Error>  {
        let path = PathBuf::from(file_path.as_ref());
        let _ = File::create(&path)?;
        Ok(Self {path})
    }
    // 1. Define the `new` associated function
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let _ = std::fs::remove_file(&self.path);
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

AtlasVakyrie

22 days ago

5.02ms

87.40kb

use std::path::PathBuf;
use std::io::Error;
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    pub fn new<T>(path: T) -> Result<Self, Error>
    where
        T: AsRef<str>,
    {
        let path = PathBuf::from(path.as_ref());
        std::fs::File::create(&path)?;
        Ok(Self { path })
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let _ = std::fs::remove_file(&self.path);
    }
}
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

AtlasVakyrie

22 days ago

4.19ms

87.40kb

use std::path::PathBuf;
use std::io::Error;
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    pub fn new<T>(path: T) -> Result<Self, Error>
    where
        T: AsRef<str>,
    {
        let path = PathBuf::from(path.as_ref());
        std::fs::File::create(&path)?;
        Ok(Self { path })
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let _ = std::fs::remove_file(&self.path);
    }
}
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

Luka Bračun

lbracun

22 days ago

3.66ms

87.40kb

use std::path::PathBuf;
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    pub fn new(path: impl AsRef<str>) -> std::io::Result<Self> {
        std::fs::File::create(&path.as_ref())?;
        Ok(Self {
            path: PathBuf::from(path.as_ref()),
        })
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let _ = std::fs::remove_file(&self.path);
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

bzdula

22 days ago

3.60ms

87.40kb

use std::path::PathBuf;
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    pub fn new(path: impl AsRef<str>) -> std::io::Result<Self> {
        std::fs::File::create(&path.as_ref())?;
        Ok(Self {
            path: PathBuf::from(path.as_ref()),
        })
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let _ = std::fs::remove_file(&self.path);
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

Wouter

WouterMartens

a month ago

4.44ms

87.40kb

use std::path::PathBuf;
use std::io::Error;
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    pub fn new<T>(path: T) -> Result<Self, Error>
    where
        T: AsRef<str>,
    {
        let path = PathBuf::from(path.as_ref());
        std::fs::File::create(&path)?;
        Ok(Self { path })
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let _ = std::fs::remove_file(&self.path);
    }
}
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

m1031

monorail103

a month ago

3.99ms

87.40kb

use std::{
    fs::{self, File},
    io::Error,
    path::PathBuf,
};
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    // 1. Define the `new` associated function
    pub fn new<T: AsRef<str>>(path: T) -> Result<Self, Error> {
        let path_buf = PathBuf::from(path.as_ref());
        File::create(&path_buf)?;
        Ok(TempFile { path: path_buf })
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        // Your code here to delete the file when TempFile is dropped
        let _e = fs::remove_file(&self.path);
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

Daniel Mestas

miel-codeai

a month ago

3.94ms

87.40kb

use std::{
    fs::{self, File},
    io::Error,
    path::PathBuf,
};
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    pub fn new<T: AsRef<str>>(path: T) -> Result<Self, Error> {
        let path = PathBuf::from(path.as_ref());
        match File::create(&path) {
            Ok(_) => Ok(Self { path: path }),
            Err(e) => Err(e),
        }
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let _ = fs::remove_file(&self.path);
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

Rocky.C

cloki0610

a month ago

5.93ms

87.42kb

use std::path::PathBuf;
use std::fs::{File,remove_file};
use std::env::temp_dir;
use std::path::Path;
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    // 1. Define the `new` associated function
    pub fn new(filename: impl AsRef<str>) -> Result<Self, std::io::Error> {
        let full_path = temp_dir().join(filename.as_ref());
        File::create(&full_path)?;
        Ok(TempFile{ path: full_path })
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        // Your code here to delete the file when TempFile is dropped
        let _ = remove_file(Path::new(&self.path));
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

slaws

a month ago

4.51ms

87.42kb

use std::path::PathBuf;
use std::fs::{File,remove_file};
use std::env::temp_dir;
use std::path::Path;
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    // 1. Define the `new` associated function
    pub fn new(filename: impl AsRef<str>) -> Result<Self, std::io::Error> {
        let full_path = temp_dir().join(filename.as_ref());
        File::create(&full_path)?;
        Ok(TempFile{ path: full_path })
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        // Your code here to delete the file when TempFile is dropped
        let _ = remove_file(Path::new(&self.path));
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

Baron Curtin

baroncurtin2

a month ago

4.23ms

87.40kb

use std::path::PathBuf;
use std::str::FromStr;
use std::fs::{File, remove_file};
use std::error::Error;
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    pub fn new<T: AsRef<str>>(file_name: T) -> Result<Self, Box<dyn Error>> {
        File::create(file_name.as_ref())?;
        Ok(Self {
            path: PathBuf::from_str(file_name.as_ref())?,
        })
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let _ = remove_file(&self.path);
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

Evrins Hu

evrins

a month ago

4.00ms

87.52kb

use std::path::PathBuf;
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    // 1. Define the `new` associated function
    pub fn new(filepath: impl AsRef<str>) -> Result<Self, std::io::Error> {
        let path = std::env::temp_dir().join(filepath.as_ref());
        std::fs::File::create(&path)?;
        Ok(Self { path })
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        // Your code here to delete the file when TempFile is dropped
        match std::fs::remove_file(self.path.as_path()) {
            Ok(_) => {}
            Err(err) => eprintln!("Failed to remove file: {}", err),
        }
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

Heino Mortensen

hmortensen83

a month ago

3.97ms

87.40kb

use std::str::FromStr;
use std::{error::Error, path::PathBuf};
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    pub fn new<T: AsRef<str>>(file_path: T) -> Result<Self, Box<dyn Error>> {
        std::fs::File::create(file_path.as_ref())?;
        Ok(Self {
            path: PathBuf::from_str(file_path.as_ref())?,
        })
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let _ = std::fs::remove_file(&self.path);
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

medzernik

a month ago

5.08ms

87.40kb

use std::path::PathBuf;
use std::str::FromStr;
use std::error::Error;
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    pub fn new<T: AsRef<str>>(file_path: T) -> Result<Self, Box<dyn Error>> {
        std::fs::File::create(file_path.as_ref())?;
        Ok(Self {path: PathBuf::from_str(file_path.as_ref())?})
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
       std::fs::remove_file(&self.path);
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

johndoe30bc

a month ago

3.90ms

87.65kb

use std::{io, path::PathBuf};
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    pub fn new<S>(file_name: S) -> Result<Self, io::Error>
    where
        S: AsRef<str>,
    {
        let tmp_dir = std::env::temp_dir();
        let path = tmp_dir.join(file_name.as_ref());
        std::fs::File::create(&path)?;
        Ok(Self { path })
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        match std::fs::remove_file(&self.path) {
            Ok(_) => (), //println!("OK: temp file {:?} was deleted", &self.path),
            Err(e) => eprint!(
                "ERROR: TempFile::drop(): can't remove file ({:?}): {e}",
                &self.path
            ),
        }
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

Cristian Prieto

cprieto

a month ago

3.81ms

87.40kb

use std::fs::OpenOptions;
use std::path::PathBuf;
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    pub fn new(path: &str) -> std::io::Result<Self> {
        let path = PathBuf::from(path);
        OpenOptions::new()
            .write(true)
            .truncate(true)
            .create(true)
            .open(&path)?;
        Ok(Self { path })
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        if self.path.exists() {
            std::fs::remove_file(&self.path)
                .expect("Could not delete temp file");
        }
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

xxxxsk

a month ago

3.67ms

87.41kb

use std::path::PathBuf;
pub struct TempFile {
     pub path: PathBuf,
}
impl TempFile {
    // 1. Define the `new` associated function
    pub fn new(name: impl AsRef<str>) -> Result<TempFile, String> {
        // Your code here to create a new TempFile instance
        if name.as_ref() == "" {
            return Err("Empty file name".to_string())
        }
        let mut path = PathBuf::from(std::env::temp_dir());
        path.push(name.as_ref());
        if path.exists() {
            return Ok(TempFile {path})
        }
        match std::fs::File::create(&path) {
            Ok(_) => Ok(TempFile {path}),
            Err(_) => Err("Failed to create file".to_string())
        }
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        // Your code here to delete the file when TempFile is dropped
        if self.path.exists() {
            std::fs::remove_file(&self.path).expect("Failed to remove file");
        }
        
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

FredoPo

a month ago

4.45ms

87.44kb

use std::{env, fs, path::PathBuf};
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    // 1. Define the `new` associated function
    pub fn new<T: AsRef<str>>(file: T) -> Result<Self, std::io::Error> {
        let tmp = env::temp_dir();
        let path_tmp = tmp.to_str().ok_or(std::io::ErrorKind::AddrNotAvailable)?;
        let path_file = format!("{}/{}", path_tmp, file.as_ref().to_string());
        fs::File::create(&path_file)?;
        Ok(
            Self {
                path: PathBuf::from(path_file)
            }
        )
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        // Your code here to delete the file when TempFile is dropped
        let _ = fs::remove_file(self.path.clone());
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

Evgenii Grigorenko

grevgeny

a month ago

3.69ms

87.42kb

use std::path::{PathBuf, Path};
use std::fs::{File, self};
use std::io;
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    pub fn new(file_path: impl AsRef<Path>) -> Result<Self, io::Error> {
        let path = std::env::temp_dir().join(file_path);
        File::create(&path)?;
        Ok(Self {
            path
        })
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let _ = fs::remove_file(&self.path);
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile = TempFile::new(&file_path).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

Procybit

a month ago

4.66ms

87.41kb

use std::{fs::File, path::PathBuf};
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    pub fn new<S: AsRef<str>>(name: S) -> Result<TempFile, String> {
        let mut path = std::env::temp_dir();
        if name.as_ref() == "" {
            return Err("Empty file name".to_string());
        }
        path.push(name.as_ref());
        if path.exists() {
            return Ok(TempFile { path });
        }
        match File::create(&path) {
            Ok(..) => Ok(TempFile { path }),
            Err(x) => Err(x.to_string()),
        }
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        if self.path.exists() {
            std::fs::remove_file(&self.path).unwrap();
        }
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

Miguel Ángel Allende

maallende

a month ago

3.99ms

87.58kb

use std::path::PathBuf;
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    // 1. Define the `new` associated function
    pub fn new(path: &str) -> Result<Self, std::io::Error> {
        let path_buf = PathBuf::from(path);
        // 2. Create the temporary file
        std::fs::File::create(&path_buf)?;
        Ok(TempFile { path: path_buf })
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        // Your code here to delete the file when TempFile is dropped
        if let Err(e) = std::fs::remove_file(&self.path) {
            eprintln!("Failed to delete temporary file {}: {}", self.path.display(), e);
        }
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

brucecox01

2 months ago

4.86ms

87.41kb

use std::fs::File;
use std::path::PathBuf;
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    // 1. Define the `new` associated function
    pub fn new<T: AsRef<str>>(filename: T) -> Result<TempFile, std::io::Error> {
        let mut path = std::env::temp_dir();
        path.push(filename.as_ref());
        let _ = File::create(&path)?;
        Ok(TempFile { path })
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        // Your code here to delete the file when TempFile is dropped
        let _ = std::fs::remove_file(&self.path);
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

Krzysztof Atłasik

katlasik

2 months ago

7.03ms

87.41kb

use std::path::PathBuf;
use std::fs::File;
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    // 1. Define the `new` associated function
    pub fn new(filename: impl AsRef<str>) -> Result<Self, Box<dyn std::error::Error>> {
        let mut path = PathBuf::new();
        path.push(std::env::temp_dir());
        path.push(filename.as_ref());
        File::create(&path)?;
        Ok(Self { path })
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        // Your code here to delete the file when TempFile is dropped
        std::fs::remove_file(&self.path);
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

Kr0wZ

2 months ago

3.95ms

87.48kb

use std::path::{PathBuf, Path};
use std::fs::File;
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    // 1. Define the `new` associated function
    pub fn new<T>(path: T) -> Result<TempFile, String>
    where 
        T: AsRef<str> + AsRef<Path> + ToString,     
    {
        if path.to_string().is_empty() {
            return Err("File name is empty".to_string());
        }
        let mut absolute_path = PathBuf::new();
        absolute_path.push(std::env::temp_dir());
        absolute_path.push(path);
        
        File::create(&absolute_path).expect("Can't create temp file");
        Ok(TempFile {
            path: absolute_path,
        })
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        // Your code here to delete the file when TempFile is dropped
        println!("Drop is called here!");
        std::fs::remove_file(&self.path);
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

Tengz Mao

MaoX-Yu

2 months ago

3.67ms

87.41kb

use std::path::PathBuf;
use std::fs::File;
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    // 1. Define the `new` associated function
    pub fn new(filename: impl AsRef<str>) -> Result<Self, Box<dyn std::error::Error>> {
        let mut path = PathBuf::new();
        path.push(std::env::temp_dir());
        path.push(filename.as_ref());
        File::create(&path)?;
        Ok(Self { path })
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        // Your code here to delete the file when TempFile is dropped
        let _ = std::fs::remove_file(&self.path);
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

Philippe Massicotte

PMassicotte

2 months ago

3.83ms

87.43kb

use std::path::PathBuf;
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    pub fn new<T>(path: T) -> std::io::Result<Self>
    where
        T: AsRef<str>,
    {
        let file = PathBuf::from(path.as_ref());
        std::fs::File::create(file.clone())?;
        Ok(Self { path: file })
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let _ = std::fs::remove_file(self.path.clone());
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

Ushakov Andrey

stdstring

2 months ago

3.59ms

87.44kb

use std::path::PathBuf;
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    // 1. Define the `new` associated function
    pub fn new<T>(temp_name: T) -> std::io::Result<Self> where T: std::convert::AsRef<str> {
        let mut temp_path = std::env::temp_dir();
        let temp_file = PathBuf::from(temp_name.as_ref());
        temp_path.push(temp_file);
        std::fs::File::create(&temp_path)?;
        Ok(TempFile{path: temp_path})
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        // Your code here to delete the file when TempFile is dropped
        //unimplemented!()
        std::fs::remove_file(&self.path);
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

Herman effendi

hrmneffdii

2 months ago

3.96ms

87.40kb

use std::path::PathBuf;
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    pub fn new<T>(p: T) -> std::io::Result<Self>
    where
        T: AsRef<str>,
    {
        let p_n = PathBuf::from(p.as_ref());
        std::fs::File::create(&p_n)?;
        Ok(Self { path: p_n })
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let _ = std::fs::remove_file(&self.path);
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

vanos001

2 months ago

3.98ms

87.43kb

use std::path::PathBuf;
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    // 1. Define the `new` associated function
    pub fn new<T>(p : T) -> std::io::Result<Self>
    where 
        T : AsRef<str>,
    {
        let p_n = PathBuf::from(p.as_ref());
        std::fs::File::create(p_n.clone())?;
        return Ok(Self{
            path : p_n,
        });
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        // Your code here to delete the file when TempFile is dropped
        // unimplemented!()
        let _ = std::fs::remove_file(self.path.clone());
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

vanos001

2 months ago

3.72ms

87.43kb

use std::path::PathBuf;
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    // 1. Define the `new` associated function
    pub fn new<T>(p : T) -> std::io::Result<Self>
    where 
        T : AsRef<str>,
    {
        let p_n = PathBuf::from(p.as_ref());
        std::fs::File::create(p_n.clone())?;
        return Ok(Self{
            path : p_n,
        });
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        // Your code here to delete the file when TempFile is dropped
        // unimplemented!()
        let _ = std::fs::remove_file(self.path.clone());
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

alexsavio

2 months ago

3.64ms

87.41kb

use std::path::PathBuf;
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    pub fn new(file_name: impl AsRef<str>) -> Result<Self, std::io::Error> {
        let mut path = std::env::temp_dir();
        path.push(file_name.as_ref());
        std::fs::File::create(&path)?;
        Ok(TempFile { path })
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let _ = std::fs::remove_file(&self.path);
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

0x0f1

Paul4673

2 months ago

4.17ms

87.43kb

use std::path::PathBuf;
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    // 1. Define the `new` associated function
    pub fn new<S>(path: S) -> Result<Self, std::io::Error>
    where S : Into<PathBuf> {
        let path = path.into();
        std::fs::File::create(&path)?;
        Ok(Self {path})
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        // Your code here to delete the file when TempFile is dropped
        let _ = std::fs::remove_file(self.path.clone());
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

Enes

enesscevik

2 months ago

5.95ms

87.43kb

use std::path::PathBuf;
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    pub fn new<T: Into<PathBuf>>(path: T) -> Result<Self, std::io::Error> {
        let path = path.into();
        std::fs::File::create(&path)?;
        Ok(Self { path })
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let _ = std::fs::remove_file(self.path.clone());
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

whhc

2 months ago

7.02ms

87.43kb

use std::path::PathBuf;
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    pub fn new<T>(path: T) -> Result<Self, std::io::Error>
    where
        T: Into<PathBuf>,
    {
        let path = path.into();
        std::fs::File::create(&path)?;
        Ok(Self { path })
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        let _ = std::fs::remove_file(self.path.clone());
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

ikatlinsky

2 months ago

3.67ms

87.43kb

use std::path::PathBuf;
use std::fs;
use std::io;
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    pub fn new<T>(name: T) -> Result<Self, io::Error>
    where
        T: Into<PathBuf>,
    {
        let path = name.into();
        fs::File::create(&path)?;
        Ok(
            Self {
                path,
            }
        )
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        fs::remove_file(self.path.clone());
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

Seth Wood

seth-wood

2 months ago

4.09ms

87.40kb

use std::path::PathBuf;
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    // 1. Define the `new` associated function
    pub fn new<T>(filepath: T) -> Result<Self, std::io::Error>
    where
        T: Into<PathBuf>,
    {
        let path = filepath.into();
        std::fs::File::create(&path)?;
        Ok(TempFile { path })
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        // Your code here to delete the file when TempFile is dropped
        let _ = std::fs::remove_file(&self.path);
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

diucicd

2 months ago

3.75ms

87.40kb

use std::{fs, io};
use std::{fs::remove_file, path::PathBuf};
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    // 1. Define the `new` associated function
    pub fn new(path: impl Into<PathBuf>) -> Result<Self, std::io::Error> {
        let path = path.into();
        fs::File::create(&path)?;
        Ok(Self { path })
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        // Your code here to delete the file when TempFile is dropped
        let _ = remove_file(&self.path);
    }
}

Sergey Matyash

matiaspub

2 months ago

4.69ms

87.43kb

use std::path::PathBuf;
use std::fs;
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    // 1. Define the `new` associated function
    pub fn new(f: impl AsRef<str>) -> Result<Self, std::io::Error> {
        let path = PathBuf::from(f.as_ref());
        fs::File::create(path.clone())?;
        Ok(Self{path})
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        // Your code here to delete the file when TempFile is dropped
        let _ = fs::remove_file(&self.path);
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

LeonardoPinheiro23

3 months ago

4.21ms

87.40kb

use std::{fs::{self, File}, io, path::{Path, PathBuf}};
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    pub fn new<P>(pathname: P) -> io::Result<Self>
    where P: AsRef<Path> + Into<PathBuf> {
        File::create(&pathname)?;
        Ok(TempFile { path: pathname.into() })
    }
}
impl Drop for TempFile {
    fn drop(&mut self) {
        // Your code here to delete the file when TempFile is dropped
        let _ = fs::remove_file(&self.path);
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}

Tommytto

3 months ago

3.83ms

87.43kb

use std::path::{Path, PathBuf};
use std::fs;
use std::fs::File;
pub struct TempFile {
    pub path: PathBuf,
}
impl TempFile {
    // 1. Define the `new` associated function
    pub fn new(file_name: impl AsRef<Path>) -> Result<Self, std::io::Error> {
        let path = PathBuf::from(file_name.as_ref());
        File::create(path.clone())?;
        Ok(Self {
            path
        })
    }
}
impl Drop for TempFile {
    fn drop(&mut self) -> () {
        fs::remove_file(self.path.clone());
        self.path = PathBuf::default();
    }
}
// Example usage
pub fn main() {
    let file_path = PathBuf::from("example_temp_file.tmp");
    let tempfile =
        TempFile::new(file_path.to_str().unwrap()).expect("Failed to create temporary file");
    assert!(tempfile.path.exists(), "File does not exist");
    drop(tempfile);
    assert!(!file_path.exists(), "File was not deleted");
    let tempfile_2 = TempFile::new(&String::from("example_temp_file_2.tmp"))
        .expect("Failed to create temporary file");
    drop(tempfile_2);
}