Tempfile

https://github.com/stebalien/tempfile
Admin
A secure, cross-platform temporary file library for Rust that allows multiple independent references...
Tokens:46,509
Snippets:342
Trust Score:9.2
License:Apache-2.0
Update:1 month ago
Show doc for...
Tokens:
Raw
### Create, write, seek, and read a temporary file

Source: https://github.com/stebalien/tempfile/blob/master/README.md

Demonstrates creating a temporary file with tempfile::tempfile(), writing to it, seeking to the start, and reading back the content. The example asserts that the read content equals "Hello World!".

```rust
use std::fs::File;
use std::io::{Write, Read, Seek, SeekFrom};

fn main() {
    // Write
    let mut tmpfile: File = tempfile::tempfile().unwrap();
    write!(tmpfile, "Hello World!").unwrap();

    // Seek to start
    tmpfile.seek(SeekFrom::Start(0)).unwrap();

    // Read
    let mut buf = String::new();
    tmpfile.read_to_string(&mut buf).unwrap();
    assert_eq!("Hello World!", buf);
}
```

--------------------------------

### Builder usage example with prefix, suffix, and rand_bytes

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/builder.md

Creates a named temporary file with a custom prefix, suffix, and 5 random bytes, then verifies the file name starts with the prefix, ends with the suffix, and has the expected length. The example uses the ? operator and requires the caller to handle std::io::Error.

```rust
use std::ffi::OsStr;
use tempfile::Builder;

let named_tempfile = Builder::new()
    .prefix("my-temporary-note")
    .suffix(".txt")
    .rand_bytes(5)
    .tempfile()?;

let name = named_tempfile.path().file_name().and_then(OsStr::to_str);
if let Some(name) = name {
    assert!(name.starts_with("my-temporary-note"));
    assert!(name.ends_with(".txt"));
    assert_eq!(name.len(), "my-temporary-note.txt".len() + 5);
}
# Ok::<(), std::io::Error>(())
```

--------------------------------

### Builder::tempfile usage example

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/builder.md

Example demonstrating the creation of a named temporary file using the Builder.

```rust
use tempfile::Builder;

let tempfile = Builder::new().tempfile()?;
# Ok::<(), std::io::Error>(())
```

--------------------------------

### TempDir::new usage example

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/dir.md

Example usage of TempDir::new. Creates a temporary directory and returns an io::Result.

```rust
use tempfile::TempDir;

let tmp_dir = TempDir::new()?;
# Ok::<(), std::io::Error>(())
```

--------------------------------

### path() usage example

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/dir.md

Shows how to use `TempDir::path()` to get the path and verify existence. The directory is dropped at the end of the block, so `exists()` returns `false` afterward.

```rust
use tempfile::TempDir;

let tmp_path;
{
    let tmp_dir = TempDir::new()?;
    tmp_path = tmp_dir.path().to_owned();
    assert!(tmp_path.exists());
} // tmp_dir dropped here
assert_eq!(tmp_path.exists(), false);
# Ok::<(), std::io::Error>(())

```

--------------------------------

### Builder::prefix usage example

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/builder.md

Usage example for `Builder::prefix`: creates a named temporary file with prefix `"my-temporary-note"`. The `?` operator is used for error handling, and the `Ok` marker finishes the example.

```rust
use tempfile::Builder;

let named_tempfile = Builder::new()
    .prefix("my-temporary-note")
    .tempfile()?;
# Ok::<(), std::io::Error>(())
```

--------------------------------

### Usage example for tempfile

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/file.md

Demonstrates creating a temporary file and writing to it.

```rust
use tempfile::tempfile;
use std::io::Write;

let mut file = tempfile()?;
writeln!(file, "Brian was here. Briefly.")?;
# Ok::<(), std::io::Error>(())
```

--------------------------------

### Usage of Builder::tempdir

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/builder.md

Example showing how to create a temporary directory using the Builder.

```rust
use tempfile::Builder;

let tmp_dir = Builder::new().tempdir()?;
# Ok::<(), std::io::Error>(())
```

--------------------------------

### try_from_path usage example

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/temppath.md

Example showing the robust version of TempPath::try_from_path, which errors instead of risking deleting the wrong file when the current directory cannot be determined.

```rust
use tempfile::TempPath;

// Robust version: errors instead of risking deleting the wrong file.
let path = TempPath::try_from_path("relative/path")?;
# Ok::<(), std::io::Error>(())
```

--------------------------------

### TempDir::with_prefix usage example

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/dir.md

Example usage of TempDir::with_prefix. Creates a temporary directory with a name prefix and asserts the prefix.

```rust
use tempfile::TempDir;

let tmp_dir = TempDir::with_prefix("foo-")?;
let tmp_name = tmp_dir.path().file_name().unwrap().to_str().unwrap();
assert!(tmp_name.starts_with("foo-"));
# Ok::<(), std::io::Error>(())
```

--------------------------------

### Example usage of Builder::make_in

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/builder.md

Demonstrates creating a UnixListener within a specified directory using the Builder pattern.

```rust
# #[cfg(unix)]
# {
use tempfile::Builder;
use std::os::unix::net::UnixListener;

let tempsock = Builder::new().make_in("./", |path| UnixListener::bind(path))?;
# }
# Ok::<(), std::io::Error>(())
```

--------------------------------

### TempDir::new_in usage example

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/dir.md

Example usage of TempDir::new_in. Creates a temporary directory in the specified parent directory.

```rust
use tempfile::TempDir;

let tmp_dir = TempDir::new_in(".")?;
# Ok::<(), std::io::Error>(())
```

--------------------------------

### new

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/spooled.md

Constructs a SpooledTempFile starting in-memory with an empty Cursor<Vec<u8>> and dir: None (backing file in OS temp dir).

```APIDOC
## new

### Description
Constructs a SpooledTempFile starting in-memory with an empty Cursor<Vec<u8>> and dir: None (backing file in OS temp dir).

### Method
new

### Signature
pub fn new(max_size: usize) -> SpooledTempFile

### Parameters
- **max_size** (usize) - Required - Roll-over threshold in bytes

### Return Type
SpooledTempFile
```

--------------------------------

### Usage of Builder::tempfile_in

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/builder.md

Example showing how to create a temporary file in the current directory using the Builder.

```rust
use tempfile::Builder;

let tempfile = Builder::new().tempfile_in("./")?;
# Ok::<(), std::io::Error>(())
```

--------------------------------

### Get default temp directory with temp_dir

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/env.md

Example of retrieving the default temporary directory. The result is not cached, so late environment changes before the first call take effect; after an override, the override wins.

```rust
use tempfile::env;

// Platform default (pre-override): std::env::temp_dir().
let default = env::temp_dir();
println!("{}", default.display());
```

--------------------------------

### Usage of Builder::tempdir_in

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/builder.md

Example showing how to create a temporary directory in the current directory using the Builder.

```rust
use tempfile::Builder;

let tmp_dir = Builder::new().tempdir_in("./")?;
# Ok::<(), std::io::Error>(())
```

--------------------------------

### TempDir::with_suffix usage example

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/dir.md

Example usage of TempDir::with_suffix. Creates a temporary directory with a name suffix and asserts the suffix.

```rust
use tempfile::TempDir;

let tmp_dir = TempDir::with_suffix("-foo")?;
let tmp_name = tmp_dir.path().file_name().unwrap().to_str().unwrap();
assert!(tmp_name.ends_with("-foo"));
# Ok::<(), std::io::Error>(())
```

--------------------------------

### Example: using tempdir() to create a temporary file

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/dir.md

Example usage of `tempdir()` to create a temporary directory, create a file inside it, write to it, and then explicitly close the directory to verify cleanup. The `?` operator propagates errors, and the final `Ok::<(), std::io::Error>(())` is a hidden line for doctests.

```rust
use tempfile::tempdir;
use std::fs::File;
use std::io::Write;

let tmp_dir = tempdir()?;
let file_path = tmp_dir.path().join("my-temporary-note.txt");
let mut tmp_file = File::create(file_path)?;
writeln!(tmp_file, "Brian was here. Briefly.")?;
tmp_dir.close()?; // verified cleanup
# Ok::<(), std::io::Error>(())
```

--------------------------------

### from_path usage example

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/temppath.md

Example showing the deprecated TempPath::from_path with a relative path, which is best-effort absolutized. Dropping the TempPath may delete the file if absolutization failed.

```rust
use tempfile::TempPath;

let tmp_path = TempPath::from_path("foo"); // relative — best effort absolutized
drop(tmp_path);
```

--------------------------------

### Builder::suffix usage example

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/builder.md

Usage example for `Builder::suffix`: creates a temporary file with suffix `.txt`. The `?` operator is used for error handling.

```rust
use tempfile::Builder;

let named_tempfile = Builder::new().suffix(".txt").tempfile()?;
# Ok::<(), std::io::Error>(())
```

--------------------------------

### keep usage example

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/temppath.md

Example showing how to use TempPath::keep to make a temporary file permanent. The returned PathBuf is no longer auto-deleted, and dropping it does nothing.

```rust
use std::io::Write;
use tempfile::NamedTempFile;

let mut file = NamedTempFile::new()?;
writeln!(file, "data")?;

let path = file.into_temp_path();
let permanent = path.keep()?;     // PathBuf, no longer auto-deleted
drop(permanent);                   // nothing happens on drop
# Ok::<(), std::io::Error>(())
```

--------------------------------

### Builder::make with UNIX domain socket

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/builder.md

Example of using Builder::make to bind a UNIX domain socket. This demonstrates the automatic retry behavior for AddrInUse errors.

```rust
# #[cfg(unix)]
# {
use std::os::unix::net::UnixListener;
use tempfile::Builder;

let tempsock = Builder::new().make(|path| UnixListener::bind(path))?;
# }
# Ok::<(), std::io::Error>(())
```

--------------------------------

### Builder::rand_bytes usage example

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/builder.md

Usage example for `Builder::rand_bytes`: creates a temporary file with 5 random characters. The `?` operator is used for error handling.

```rust
use tempfile::Builder;

let named_tempfile = Builder::new().rand_bytes(5).tempfile()?;
# Ok::<(), std::io::Error>(())
```

--------------------------------

### tempfile_in usage example

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/file.md

Creates a temporary file in the current directory and writes to it.

```rust
use tempfile::tempfile_in;
use std::io::Write;

let mut file = tempfile_in("./")?;
writeln!(file, "Brian was here. Briefly.")?;
# Ok::<(), std::io::Error>(())
```

--------------------------------

### Builder::disable_cleanup usage example

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/builder.md

Example demonstrating how to use disable_cleanup(true) to prevent automatic deletion of a NamedTempFile.

```rust
use tempfile::Builder;

let named_tempfile = Builder::new().disable_cleanup(true).tempfile()?;
# Ok::<(), std::io::Error>(())
```

--------------------------------

### spooled_tempfile_in usage example

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/spooled.md

Example of using spooled_tempfile_in to create a spooled file with a 1024-byte threshold, placing the backing file in /var/tmp. Writes a short line to the file.

```rust
use tempfile::spooled_tempfile_in;
use std::io::Write;

// Backing file lands in /var/tmp (a real disk), not the OS tmp.
let mut file = spooled_tempfile_in(1024, "/var/tmp");
writeln!(file, "hello")?;
# Ok::<(), std::io::Error>(())
```

--------------------------------

### spooled_tempfile usage example

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/spooled.md

Example of using spooled_tempfile to create a spooled file with a 15-byte threshold. Writes a short line that stays in memory, then a longer line that triggers roll-over to disk.

```rust
use tempfile::spooled_tempfile;
use std::io::Write;

let mut file = spooled_tempfile(15);

writeln!(file, "short line")?;
assert!(!file.is_rolled());

// This write pushes the size past max_size (15) — rolls to disk.
writeln!(file, "marvin gardens")?;
assert!(file.is_rolled());
# Ok::<(), std::io::Error>(())
```

--------------------------------

### Example: using tempdir_in() to create a temp dir in a specific location

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/dir.md

Example usage of `tempdir_in()` to create a temporary directory in the current directory (`.`). The `?` operator propagates errors, and the final `Ok::<(), std::io::Error>(())` is a hidden line for doctests.

```rust
use tempfile::tempdir_in;

let tmp_dir = tempdir_in(".")?;
# Ok::<(), std::io::Error>(())
```

--------------------------------

### Persist a TempPath

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/temppath.md

Example of persisting a temporary file to a specific destination path.

```rust
use std::io::Write;
use tempfile::NamedTempFile;

let mut file = NamedTempFile::new()?;
writeln!(file, "Brian was here. Briefly.")?;

let path = file.into_temp_path();
path.persist("./saved_file.txt")?;
# Ok::<(), std::io::Error>(())
```

--------------------------------

### Builder::permissions usage

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/builder.md

Sets the filesystem permissions for the new temporary file using std::fs::Permissions. This example demonstrates setting permissions on Unix systems using PermissionsExt.

```rust
# #[cfg(unix)]
# {
use tempfile::Builder;
use std::os::unix::fs::PermissionsExt;

let all_read_write = std::fs::Permissions::from_mode(0o666);
let tempfile = Builder::new().permissions(all_read_write).tempfile()?;
let actual_permissions = tempfile.path().metadata()?.permissions();
assert_eq!(actual_permissions.mode() & 0o044, 0o044);
# }
# Ok::<(), std::io::Error>(())
```

--------------------------------

### Persist a TempPath without clobbering

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/temppath.md

Example of using persist_noclobber, including error handling to close the path if persistence fails.

```rust
use tempfile::NamedTempFile;

let path = NamedTempFile::new()?.into_temp_path();
match path.persist_noclobber("./brand_new.txt") {
    Ok(()) => {}
    Err(e) => {
        // e: PathPersistError — e.path is the still-live TempPath.
        e.path.close()?;
    }
}
# Ok::<(), std::io::Error>(())
```

--------------------------------

### close() usage example

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/dir.md

Shows calling `TempDir::close()` for verified recursive deletion. The `?` operator surfaces any `io::Error` from deleting files or directories.

```rust
use tempfile::TempDir;

let tmp_dir = TempDir::new()?;
tmp_dir.close()?; // verified recursive deletion
# Ok::<(), std::io::Error>(())

```

--------------------------------

### Override global temp directory with override_temp_dir

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/env.md

Example of overriding the global temp directory once and then using implicit-dir constructors. The override is process-global and can only be set once; subsequent calls return the previous override as an error.

```rust
use tempfile::env;
use std::path::Path;

// Initialize the global temp dir once (e.g., in main()).
match env::override_temp_dir(Path::new("/var/tmp/myapp")) {
    Ok(()) => println!("temp dir overridden"),
    Err(previous) => eprintln!("already set to {}", previous.display()),
}

// All subsequent implicit-dir constructors use the override:
let file = tempfile::tempfile()?;
let dir = tempfile::tempdir()?;
# Ok::<(), std::io::Error>(())
```

--------------------------------

### Builder::new

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/builder.md

Documentation for the `Builder::new` constructor method.

```APIDOC
## Builder::new

### Description
Creates a new `Builder` with default configuration. The default settings are `random_len = 6`, `prefix = ".tmp"`, `suffix = ""`, `append = false`, `permissions = None`, and `disable_cleanup = false`.

### Method
`pub fn new() -> Self`

### Parameters
None.

### Return Value
A `Builder` instance with default configuration.

### Example
```rust
use std::ffi::OsStr;
use tempfile::Builder;

let named_tempfile = Builder::new()
    .prefix("my-temporary-note")
    .suffix(".txt")
    .rand_bytes(5)
    .tempfile()?;

let name = named_tempfile.path().file_name().and_then(OsStr::to_str);
if let Some(name) = name {
    assert!(name.starts_with("my-temporary-note"));
    assert!(name.ends_with(".txt"));
    assert_eq!(name.len(), "my-temporary-note.txt".len() + 5);
}
# Ok::<(), std::io::Error>(())
```
```

--------------------------------

### new_in

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/spooled.md

Same as new but stores dir for the backing file.

```APIDOC
## new_in

### Description
Same as new but stores dir for the backing file.

### Method
new_in

### Signature
pub fn new_in<P: AsRef<Path>>(max_size: usize, dir: P) -> SpooledTempFile

### Parameters
- **max_size** (usize) - Required - Roll-over threshold in bytes
- **dir** (P: AsRef<Path>) - Required - Directory for the backing temp file

### Return Type
SpooledTempFile
```

--------------------------------

### Import paths for tempdir, tempdir_in, and TempDir

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/dir.md

Shows the required `use` statements to import the `tempdir`, `tempdir_in`, and `TempDir` items from the `tempfile` crate.

```rust
use tempfile::tempdir;
use tempfile::tempdir_in;
use tempfile::TempDir;
```

--------------------------------

### TempDir::with_prefix_in

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/dir.md

Creates a new temporary directory with a specified prefix in a specified parent directory.

```APIDOC
## TempDir::with_prefix_in

### Description
Creates a new temporary directory with a specified prefix in a specified parent directory.

### Method
Constructor

### Signature
```rust
pub fn with_prefix_in<S: AsRef<OsStr>, P: AsRef<Path>>(prefix: S, dir: P) -> io::Result<TempDir>
```

### Parameters
- `prefix` (S: AsRef<OsStr>) - Required - The prefix for the temporary directory name.
- `dir` (P: AsRef<Path>) - Required - Parent directory where the temporary directory will be created.

### Returns
- `io::Result<TempDir>` - The created temporary directory or an I/O error.
```

--------------------------------

### TempDir::with_prefix

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/dir.md

Creates a new temporary directory with a specified prefix in the system's default temp directory.

```APIDOC
## TempDir::with_prefix

### Description
Creates a new temporary directory with a specified prefix in the system's default temp directory.

### Method
Constructor

### Signature
```rust
pub fn with_prefix<S: AsRef<OsStr>>(prefix: S) -> io::Result<TempDir>
```

### Parameters
- `prefix` (S: AsRef<OsStr>) - Required - The prefix for the temporary directory name.

### Returns
- `io::Result<TempDir>` - The created temporary directory or an I/O error.

### Example
```rust
use tempfile::TempDir;

let tmp_dir = TempDir::with_prefix("foo-")?;
let tmp_name = tmp_dir.path().file_name().unwrap().to_str().unwrap();
assert!(tmp_name.starts_with("foo-"));
# Ok::<(), std::io::Error>(())
```
```

--------------------------------

### Close a TempPath

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/temppath.md

Example of closing a temporary file path, which triggers deletion.

```rust
use tempfile::NamedTempFile;

let file = NamedTempFile::new()?;
let path = file.into_temp_path();
path.close()?; // verified deletion
# Ok::<(), std::io::Error>(())
```

--------------------------------

### NamedTempFile::new

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/namedtempfile.md

Creates a named temporary file in the system's temporary directory.

```APIDOC
## NamedTempFile::new

### Description
Creates a named temporary file in `env::temp_dir()` — equivalent to `Builder::new().tempfile()`.

### Method
`pub fn new() -> io::Result<NamedTempFile>`

### Parameters
None.

### Return Type
`io::Result<NamedTempFile>` (i.e., `NamedTempFile<File>`).

### Errors
`io::Error` if the file cannot be created.

### Example
```rust
use std::io::Write;
use tempfile::NamedTempFile;

let mut file = NamedTempFile::new()?;
writeln!(file, "Brian was here. Briefly.")?;
# Ok::<(), std::io::Error>(())
```
```

--------------------------------

### NamedTempFile::with_prefix_in

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/namedtempfile.md

Creates a named temporary file with a specified prefix in a specified directory.

```APIDOC
## NamedTempFile::with_prefix_in

### Description
Equivalent to `Builder::new().prefix(&prefix).tempfile_in(dir)`. Creates a temporary file with the given prefix in the given directory.

### Method
`pub fn with_prefix_in<S: AsRef<OsStr>, P: AsRef<Path>>(prefix: S, dir: P) -> io::Result<NamedTempFile>`

### Parameters
#### Parameters
- **prefix** (`S: AsRef<OsStr>`) - Required - Prefix for the file name
- **dir** (`P: AsRef<Path>`) - Required - Directory for the new file

### Return Type
`io::Result<NamedTempFile>`

### Example
```rust
use tempfile::NamedTempFile;

let file = NamedTempFile::with_prefix_in("note-", "./")?
    .into_temp_path();
let name = file.file_name().and_then(|s| s.to_str());
assert!(name.unwrap().starts_with("note-"));
```
```

--------------------------------

### as_file / as_file_mut

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/namedtempfile.md

Borrow the underlying handle (e.g., to use APIs not covered by the Read/Write impls).

```APIDOC
## as_file / as_file_mut

### Description
Borrow the underlying handle (e.g., to use APIs not covered by the Read/Write impls).

### Method
as_file / as_file_mut

### Signature
pub fn as_file(&self) -> &F
pub fn as_file_mut(&mut self) -> &mut F

### Parameters
None

### Return Type
&F / &mut F

### Example
No example provided.
```

--------------------------------

### keep() usage example

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/dir.md

Shows `TempDir::keep()` preventing auto-deletion. The caller must clean up manually with `fs::remove_dir_all`.

```rust
use std::fs;
use tempfile::TempDir;

let tmp_dir = TempDir::new()?;
let tmp_path = tmp_dir.keep();        // no longer auto-deleted
fs::remove_dir_all(tmp_path)?;        // caller cleans up
# Ok::<(), std::io::Error>(())

```

--------------------------------

### Unsupported permission changes error - Other

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/errors.md

On Windows, passing a Permissions whose readonly() is true makes file or directory creation fail. Produced by create_named in src/file/imp/windows.rs and dir::create in src/dir/imp/any.rs (non-unix).

```rust
io::Error::new(io::ErrorKind::Other, "changing permissions is not supported on this platform")
```

--------------------------------

### TempDir::new

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/dir.md

Creates a new temporary directory in the system's default temp directory with a randomly generated name.

```APIDOC
## TempDir::new

### Description
Creates a new temporary directory in the system's default temp directory with a randomly generated name.

### Method
Constructor

### Signature
```rust
pub fn new() -> io::Result<TempDir>
```

### Parameters
None

### Returns
- `io::Result<TempDir>` - The created temporary directory or an I/O error.

### Example
```rust
use tempfile::TempDir;

let tmp_dir = TempDir::new()?;
# Ok::<(), std::io::Error>(())
```
```

--------------------------------

### Create independent handles with NamedTempFile::reopen

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/namedtempfile.md

Demonstrates creating a temporary file and opening a second independent handle to the same file using the reopen method.

```rust
use tempfile::NamedTempFile;
use std::io::{Write, Read};

let text = "Brian was here. Briefly.";

let mut file1 = NamedTempFile::new()?;
let mut file2 = file1.reopen()?;   // independent handle

file1.write_all(text.as_bytes())?;
let mut buf = String::new();
file2.read_to_string(&mut buf)?;
assert_eq!(buf, text);
# Ok::<(), std::io::Error>(())
```

--------------------------------

### Reusing file after failed persist with PersistError

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/file.md

Shows how to recover the NamedTempFile from a PersistError after a failed persist call. The From<PersistError<F>> for NamedTempFile<F> impl extracts the file handle and path, allowing continued use. The example uses a non-existent target path to trigger the error.

```rust
use std::io::Write;
use tempfile::NamedTempFile;

let file = NamedTempFile::new()?;

match file.persist("/target/that/does/not/exist/x.txt") {
    Ok(persisted) => writeln!(&persisted, "moved!")?,
    Err(e) => {
        // e: PersistError. The file handle + path are recoverable.
        let mut file: NamedTempFile = e.into(); // From<PersistError<F>> for NamedTempFile<F>
        writeln!(file, "still usable after failed persist")?;
    }
}
# Ok::<(), std::io::Error>(())
```

--------------------------------

### NamedTempFile::with_prefix

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/namedtempfile.md

Creates a named temporary file with a specified prefix in the default temp directory.

```APIDOC
## NamedTempFile::with_prefix

### Description
Equivalent to `Builder::new().prefix(&prefix).tempfile()`. Creates a temporary file with the given prefix.

### Method
`pub fn with_prefix<S: AsRef<OsStr>>(prefix: S) -> io::Result<NamedTempFile>`

### Parameters
#### Parameters
- **prefix** (`S: AsRef<OsStr>`) - Required - Prefix for the file name

### Return Type
`io::Result<NamedTempFile>`
```

--------------------------------

### TempDir::with_suffix_in

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/dir.md

Creates a new temporary directory with a specified suffix in a specified parent directory.

```APIDOC
## TempDir::with_suffix_in

### Description
Creates a new temporary directory with a specified suffix in a specified parent directory.

### Method
Constructor

### Signature
```rust
pub fn with_suffix_in<S: AsRef<OsStr>, P: AsRef<Path>>(suffix: S, dir: P) -> io::Result<TempDir>
```

### Parameters
- `suffix` (S: AsRef<OsStr>) - Required - The suffix for the temporary directory name.
- `dir` (P: AsRef<Path>) - Required - Parent directory where the temporary directory will be created.

### Returns
- `io::Result<TempDir>` - The created temporary directory or an I/O error.
```

--------------------------------

### TempDir::with_suffix

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/dir.md

Creates a new temporary directory with a specified suffix in the system's default temp directory.

```APIDOC
## TempDir::with_suffix

### Description
Creates a new temporary directory with a specified suffix in the system's default temp directory.

### Method
Constructor

### Signature
```rust
pub fn with_suffix<S: AsRef<OsStr>>(suffix: S) -> io::Result<TempDir>
```

### Parameters
- `suffix` (S: AsRef<OsStr>) - Required - The suffix for the temporary directory name.

### Returns
- `io::Result<TempDir>` - The created temporary directory or an I/O error.

### Example
```rust
use tempfile::TempDir;

let tmp_dir = TempDir::with_suffix("-foo")?;
let tmp_name = tmp_dir.path().file_name().unwrap().to_str().unwrap();
assert!(tmp_name.ends_with("-foo"));
# Ok::<(), std::io::Error>(())
```
```

--------------------------------

### Builder::make closure error handling

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/builder.md

Demonstrates that closure errors are propagated. Note that using File::create is insecure as it does not prevent clobbering existing files.

```rust
use std::fs::File;
use tempfile::Builder;

// NOT secure: does not fail on existing files (File::create overwrites).
// The closure itself must use create_new / exclusive binds.
let tempfile = Builder::new().make(|path| File::create(path))?;
# Ok::<(), std::io::Error>(())
```

--------------------------------

### path

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/namedtempfile.md

Returns the temporary file's path.

```APIDOC
## path

### Description
Returns the temporary file's path.

### Method
path

### Signature
pub fn path(&self) -> &Path

### Parameters
None

### Return Type
&std::path::Path

### Example
```rust
use tempfile::NamedTempFile;

let file = NamedTempFile::new()?;
println!("{:?}", file.path());
# Ok::<(), std::io::Error>(())
```
```

--------------------------------

### Import paths for tempfile module

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/file.md

Standard import paths for accessing the tempfile module components.

```rust
use tempfile::tempfile;
use tempfile::tempfile_in;
use tempfile::{PersistError, PathPersistError};
use tempfile::{NamedTempFile, TempPath}; // also defined here — see dedicated pages
```

--------------------------------

### Unsupported platforms error - Other

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/errors.md

On targets that are not unix/redox/wasi/windows, every file operation fails with this error. Produced by create_named, create, reopen, persist, and keep in src/file/imp/other.rs.

```rust
io::Error::new(io::ErrorKind::Other, "operation not supported on this platform")
```

--------------------------------

### TempDir::with_prefix_in signature

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/dir.md

Signature for TempDir::with_prefix_in. Equivalent to Builder::new().prefix(&prefix).tempdir_in(dir).

```rust
pub fn with_prefix_in<S: AsRef<OsStr>, P: AsRef<Path>>(prefix: S, dir: P) -> io::Result<TempDir>
```

--------------------------------

### TempDir::with_prefix signature

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/dir.md

Signature for TempDir::with_prefix. Equivalent to Builder::new().prefix(&prefix).tempdir().

```rust
pub fn with_prefix<S: AsRef<OsStr>>(prefix: S) -> io::Result<TempDir>
```

--------------------------------

### tempdir

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/dir.md

Creates a temporary directory in the system's default temp directory. The directory and its contents are automatically deleted when the returned TempDir is dropped.

```APIDOC
## `tempdir`

### Description
Creates a temporary directory in `env::temp_dir()` — equivalent to `TempDir::new()`. The directory and everything in it is recursively deleted when the returned `TempDir` is dropped.

### Signature
```rust
pub fn tempdir() -> io::Result<TempDir>
```

### Parameters
None.

### Return Type
`io::Result<TempDir>`

### Errors
`io::Error` if the directory cannot be created (including the "too many temporary files exist" `AlreadyExists` after exhausting retries).

### Security Note
Directories are created with *default* permissions (unless `Builder::permissions` is used), so they may be world-readable depending on umask — unlike temp *files*, which are private by default.

### Example
```rust
use tempfile::tempdir;
use std::fs::File;
use std::io::Write;

let tmp_dir = tempdir()?;
let file_path = tmp_dir.path().join("my-temporary-note.txt");
let mut tmp_file = File::create(file_path)?;
writeln!(tmp_file, "Brian was here. Briefly.")?;
tmp_dir.close()?; // verified cleanup
# Ok::<(), std::io::Error>(())
```
```

--------------------------------

### Import spooled_tempfile, spooled_tempfile_in, SpooledTempFile, SpooledData

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/spooled.md

Import the spooled module's public API from the crate root. The crate root re-exports these items at the top level.

```rust
use tempfile::spooled_tempfile;      // in-memory -> disk spool
use tempfile::spooled_tempfile_in;
use tempfile::{SpooledTempFile, SpooledData};
```

--------------------------------

### Import tempfile::env module

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/env.md

Import the env module from the tempfile crate to access the global temporary directory functions.

```rust
use tempfile::env;
```

--------------------------------

### Builder::tempfile

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/builder.md

Creates a named temporary file in the system's temporary directory. Retries with a new name if a collision occurs.

```APIDOC
## Builder::tempfile

### Description
Creates a named temporary file inside env::temp_dir(). Equivalent to self.tempfile_in(env::temp_dir()). If the name collides (AlreadyExists), a new name is tried (up to NUM_RETRIES = 65536).

### Method
Builder method (Rust)

### Signature
pub fn tempfile(&self) -> io::Result<NamedTempFile>

### Parameters
None

### Return
io::Result<NamedTempFile> - On error, the generated path is attached to the io::Error message ("... at path ...").

### Example
```rust
use tempfile::Builder;

let tempfile = Builder::new().tempfile()?;
# Ok::<(), std::io::Error>(())
```
```

--------------------------------

### persist_noclobber

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/namedtempfile.md

Like persist, but fails if a file already exists at the destination.

```APIDOC
## persist_noclobber

### Description
Like persist, but fails if a file already exists at new_path. Not guaranteed to be atomic on all platforms (though generally atomic on Windows and modern Linux filesystems); on failure it may leave a hard link behind so both names point at the same file.

### Method
persist_noclobber

### Signature
pub fn persist_noclobber<P: AsRef<Path>>(self, new_path: P) -> Result<F, PersistError<F>>

### Parameters
#### Parameters
- **new_path** (P: AsRef<Path>) - Required - Destination path

### Return Type
Result<F, PersistError<F>>

### Errors
PersistError<F>: destination exists, or move failed.

### Example
```rust
use tempfile::NamedTempFile;

let file = NamedTempFile::new()?;
match file.persist_noclobber("./unique_target.txt") {
    Ok(_) => println!("persisted"),
    Err(e) => {
        // e.error.kind() tells you why; e.file gives the file back.
        let _file: NamedTempFile = e.into();
    }
}
# Ok::<(), std::io::Error>(())
```
```

--------------------------------

### from_path (deprecated) method signature

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/temppath.md

Deprecated signature for TempPath::from_path, which creates a TempPath from an existing path (need not exist). Attempts to absolutize relative paths; if current_dir() fails, the relative path is kept as-is and cleanup may delete the wrong file. Empty paths are ignored. disable_cleanup is initialized to false.

```rust
#[deprecated = "use TempPath::try_from_path"]
pub fn from_path(path: impl Into<PathBuf>) -> Self
```

--------------------------------

### Builder::make_in

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/builder.md

Creates a named temporary file in the specified directory. The closure `f` is called with the generated path and must return the object to be bound to the file.

```APIDOC
## Builder::make_in

### Description
Creates a named temporary file in the specified directory. The closure `f` is called with the generated path and must return the object to be bound to the file.

### Signature
```rust
pub fn make_in<F, R, P>(&self, dir: P, mut f: F) -> io::Result<NamedTempFile<R>>
where
    F: FnMut(&Path) -> io::Result<R>,
    P: AsRef<Path>,
```

### Parameters
- `dir` (P: AsRef<Path>) - Required - Base directory for the generated path
- `f` (F: FnMut(&Path) -> io::Result<R>) - Required - Closure returning the object bound to the path

### Returns
`io::Result<NamedTempFile<R>>`

### Example
```rust
# #[cfg(unix)]
# {
use tempfile::Builder;
use std::os::unix::net::UnixListener;

let tempsock = Builder::new().make_in("./", |path| UnixListener::bind(path))?;
# }
# Ok::<(), std::io::Error>(())
```
```

--------------------------------

### NamedTempFile::with_suffix_in

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/namedtempfile.md

Creates a named temporary file with a specified suffix in a specified directory.

```APIDOC
## NamedTempFile::with_suffix_in

### Description
Equivalent to `Builder::new().suffix(&suffix).tempfile_in(dir)`. Creates a temporary file with the given suffix in the given directory.

### Method
`pub fn with_suffix_in<S: AsRef<OsStr>, P: AsRef<Path>>(suffix: S, dir: P) -> io::Result<NamedTempFile>`

### Parameters
#### Parameters
- **suffix** (`S: AsRef<OsStr>`) - Required - Suffix for the file name
- **dir** (`P: AsRef<Path>`) - Required - Directory for the new file

### Return Type
`io::Result<NamedTempFile>`
```

--------------------------------

### Builder::tempfile method signature

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/builder.md

The method signature for creating a named temporary file within the system's default temporary directory.

```rust
pub fn tempfile(&self) -> io::Result<NamedTempFile>
```

--------------------------------

### Builder::make

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/builder.md

Creates an arbitrary object at a generated path inside `env::temp_dir()` using the provided closure. The closure receives a candidate path and returns the object. Retries on `io::ErrorKind::AlreadyExists` and `io::ErrorKind::AddrInUse`. Any other closure error is propagated immediately. `Builder::append` is ignored. Security: the closure must handle atomic no-clobber creation.

```APIDOC
## Builder::make

### Description
Creates an arbitrary object at a generated path inside `env::temp_dir()` using the provided closure. The closure receives a candidate path and returns the object. Retries on `io::ErrorKind::AlreadyExists` and `io::ErrorKind::AddrInUse`. Any other closure error is propagated immediately. `Builder::append` is ignored. Security: the closure must handle atomic no-clobber creation.

### Signature
```rust
pub fn make<F, R>(&self, f: F) -> io::Result<NamedTempFile<R>>
where
    F: FnMut(&Path) -> io::Result<R>,
```

### Parameters
- `f` (F: FnMut(&Path) -> io::Result<R>) - Required - Closure receiving a candidate path, returning the file-like object.

### Returns
`io::Result<NamedTempFile<R>>` where `R` is the closure's object type.

### Example (UNIX domain socket)
```rust
# #[cfg(unix)]
# {
use std::os::unix::net::UnixListener;
use tempfile::Builder;

let tempsock = Builder::new().make(|path| UnixListener::bind(path))?;
# }
# Ok::<(), std::io::Error>(())
```

### Error Handling
Closure errors are propagated unless they are retriable (`AlreadyExists` or `AddrInUse`).

### Security Note
The closure itself is responsible for atomic no-clobber creation (e.g., via `create_new`), otherwise a TOCTOU race exists.

### Example (Insecure usage)
```rust
use std::fs::File;
use tempfile::Builder;

// NOT secure: does not fail on existing files (File::create overwrites).
// The closure itself must use create_new / exclusive binds.
let tempfile = Builder::new().make(|path| File::create(path))?;
# Ok::<(), std::io::Error>(())
```
```

--------------------------------

### NamedTempFile::new usage

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/namedtempfile.md

Creates a named temporary file in the system's default temporary directory.

```rust
use std::io::Write;
use tempfile::NamedTempFile;

let mut file = NamedTempFile::new()?;
writeln!(file, "Brian was here. Briefly.")?;
# Ok::<(), std::io::Error>(())
```

--------------------------------

### Convert to file with into_file

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/spooled.md

Converts the spooled file into a standard File, ensuring data is written to disk if it was still in memory.

```rust
use tempfile::spooled_tempfile;
use std::io::Write;

let mut spooled = spooled_tempfile(5);
writeln!(spooled, "some data")?; // exceeds 5 bytes -> on disk
let file = spooled.into_file()?; // plain File, OS-managed cleanup
# Ok::<(), std::io::Error>(())
```

--------------------------------

### tempfile()

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/file.md

Creates a new unnamed temporary file in the system temp directory. The file is automatically removed when the last handle is closed.

```APIDOC
## tempfile()

### Description
Creates a new unnamed temporary file in `env::temp_dir()` (i.e., `tempfile_in(env::temp_dir())`). The file is removed by the OS when the last handle is closed — this variant is secure and reliable even in the presence of a pathological temporary file cleaner, and does not rely on Rust destructors.

### Method
Function

### Signature
```rust
pub fn tempfile() -> io::Result<File>
```

### Parameters
None

### Return Type
`io::Result<std::fs::File>` — a fully open, readable-and-writable `File`.

### Errors
`io::Error` if the file cannot be created (including the permanent "too many temporary files exist" `AlreadyExists` after 65536 collisions, or the WASI panic documented in [configuration.md](../configuration.md)).

### Platform Implementation Notes
- On Linux, attempts `O_TMPFILE` (create_unlinked semantics via `rustix`), falling back to "create + immediately unlink" on `OPNOTSUPP`/`ISDIR`/`NOENT`.
- Non-Linux unix/wasi uses the fallback directly.
- Windows uses `FILE_FLAG_DELETE_ON_CLOSE | FILE_ATTRIBUTE_TEMPORARY` with `share_mode(0)`.

### Example
```rust
use tempfile::tempfile;
use std::io::Write;

let mut file = tempfile()?;
writeln!(file, "Brian was here. Briefly.")?;
# Ok::<(), std::io::Error>(())
```
```

--------------------------------

### Builder::permissions

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/builder.md

Sets the permissions for the new temporary file or directory. The permissions are applied subject to platform-specific behavior, such as umask on Unix and readonly handling on Windows.

```APIDOC
## `Builder::permissions`

### Description
Sets the permissions for the new temporary file/directory. `permissions` is `std::fs::Permissions`.

### Method
`pub fn permissions(&mut self, permissions: Permissions) -> &mut Self`

### Parameters
- `permissions` (std::fs::Permissions) - Required - Permission bits for the created file/dir

### Return
`&mut Self`

### Defaults and Platform Behavior
- Temp files default to `0o600`, temp dirs to `0o777` (before umask).
- **Unix:** actual bits are `permissions & !umask` — never more permissive than requested.
- **Windows:** a `Permissions` with `readonly() == true` makes creation fail with an error.
- **WASI:** permissions accepted but ignored.

### Example
```rust
# #[cfg(unix)]
# {
use tempfile::Builder;
use std::os::unix::fs::PermissionsExt;

let all_read_write = std::fs::Permissions::from_mode(0o666);
let tempfile = Builder::new().permissions(all_read_write).tempfile()?;
let actual_permissions = tempfile.path().metadata()?.permissions();
assert_eq!(actual_permissions.mode() & 0o044, 0o044);
# }
# Ok::<(), std::io::Error>(())
```
```

--------------------------------

### TempDir::new_in signature

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/dir.md

Signature for TempDir::new_in. Equivalent to Builder::new().tempdir_in(dir). Takes a parent directory path.

```rust
pub fn new_in<P: AsRef<Path>>(dir: P) -> io::Result<TempDir>
```

--------------------------------

### TempPath::from_path (deprecated)

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/temppath.md

Creates a TempPath from an existing path (the path need not exist). Attempts to absolutize relative paths against the current directory; if std::env::current_dir() fails, the relative path is kept as-is and cleanup may delete the wrong file. Deprecated in favor of try_from_path.

```APIDOC
## TempPath::from_path (deprecated)

### Description
Creates a `TempPath` from an existing path (the path need not exist). Attempts to absolutize relative paths against the current directory; **if `std::env::current_dir()` fails, the relative path is kept as-is and cleanup may delete the wrong file** — this is why the method is deprecated. Empty paths are ignored (kept as-is). `disable_cleanup` is initialized to `false`.

### Method
`from_path`

### Signature
```rust
#[deprecated = "use TempPath::try_from_path"]
pub fn from_path(path: impl Into<PathBuf>) -> Self
```

### Parameters
- `path` (`impl Into<PathBuf>`) - Required - Any path, relative or absolute.

### Return Type
`Self` (i.e., `TempPath`)

### Example
```rust
use tempfile::TempPath;

let tmp_path = TempPath::from_path("foo"); // relative — best effort absolutized
drop(tmp_path);
```
```

--------------------------------

### Builder::new signature

Source: https://github.com/stebalien/tempfile/blob/master/_autodocs/api-reference/builder.md

The new() constructor returns a Builder with default configuration. It is marked #[must_use].

```rust
#[must_use]
pub fn new() -> Self
```
Tokens:
Raw