# Struct std::fs::OpenOptions [−] [src]

    pub struct OpenOptions(_);

Options and flags which can be used to configure how a file is opened.

This builder exposes the ability to configure how a `File` is opened and what operations are permitted on the open file. The `File::open` and `File::create` methods are aliases for commonly used options using this builder.

Generally speaking, when using `OpenOptions`, you'll first call `new()`, then chain calls to methods to set each option, then call `open()`, passing the path of the file you're trying to open. This will give you a `io::Result` with a `File` inside that you can further operate on.

# Examples

Opening a file to read:

fn main() { use std::fs::OpenOptions; let file = OpenOptions::new().read(true).open("foo.txt"); }

    use std::fs::OpenOptions;

    let file = OpenOptions::new().read(true).open("foo.txt");

Opening a file for both reading and writing, as well as creating it if it doesn't exist:

fn main() { use std::fs::OpenOptions; let file = OpenOptions::new() .read(true) .write(true) .create(true) .open("foo.txt"); }

    use std::fs::OpenOptions;

    let file = OpenOptions::new()
                .read(true)
                .write(true)
                .create(true)
                .open("foo.txt");

## Methods

### `impl OpenOptions`

#### `fn new() -> OpenOptions`

Creates a blank net set of options ready for configuration.

All options are initially set to `false`.

# Examples

fn main() { use std::fs::OpenOptions; let file = OpenOptions::new().open("foo.txt"); }

    use std::fs::OpenOptions;

    let file = OpenOptions::new().open("foo.txt");

#### `fn read(&mut self, read: bool) -> &mut OpenOptions`

Sets the option for read access.

This option, when true, will indicate that the file should be `read`-able if opened.

# Examples

fn main() { use std::fs::OpenOptions; let file = OpenOptions::new().read(true).open("foo.txt"); }

    use std::fs::OpenOptions;

    let file = OpenOptions::new().read(true).open("foo.txt");

#### `fn write(&mut self, write: bool) -> &mut OpenOptions`

Sets the option for write access.

This option, when true, will indicate that the file should be `write`-able if opened.

# Examples

fn main() { use std::fs::OpenOptions; let file = OpenOptions::new().write(true).open("foo.txt"); }

    use std::fs::OpenOptions;

    let file = OpenOptions::new().write(true).open("foo.txt");

#### `fn append(&mut self, append: bool) -> &mut OpenOptions`

Sets the option for the append mode.

This option, when true, means that writes will append to a file instead of overwriting previous contents.

# Examples

fn main() { use std::fs::OpenOptions; let file = OpenOptions::new().write(true).append(true).open("foo.txt"); }

    use std::fs::OpenOptions;

    let file = OpenOptions::new().write(true).append(true).open("foo.txt");

#### `fn truncate(&mut self, truncate: bool) -> &mut OpenOptions`

Sets the option for truncating a previous file.

If a file is successfully opened with this option set it will truncate the file to 0 length if it already exists.

# Examples

fn main() { use std::fs::OpenOptions; let file = OpenOptions::new().write(true).truncate(true).open("foo.txt"); }

    use std::fs::OpenOptions;

    let file = OpenOptions::new().write(true).truncate(true).open("foo.txt");

#### `fn create(&mut self, create: bool) -> &mut OpenOptions`

Sets the option for creating a new file.

This option indicates whether a new file will be created if the file does not yet already exist.

# Examples

fn main() { use std::fs::OpenOptions; let file = OpenOptions::new().create(true).open("foo.txt"); }

    use std::fs::OpenOptions;

    let file = OpenOptions::new().create(true).open("foo.txt");

#### `fn open<P: AsRef<Path>>(&self, path: P) -> Result<File>`

Opens a file at `path` with the options specified by `self`.

# Errors

This function will return an error under a number of different circumstances, to include but not limited to:

- Opening a file that does not exist with read access.
- Attempting to open a file with access that the user lacks permissions for
- Filesystem-level errors (full disk, etc)

# Examples

fn main() { use std::fs::OpenOptions; let file = OpenOptions::new().open("foo.txt"); }

    use std::fs::OpenOptions;

    let file = OpenOptions::new().open("foo.txt");

## Trait Implementations

### `impl OpenOptionsExt for OpenOptions`

#### `fn mode(&mut self, mode: mode_t) -> &mut OpenOptions`

### `impl OpenOptionsExt for OpenOptions`

#### `fn mode(&mut self, mode: mode_t) -> &mut OpenOptions`

### Derived Implementations

### `impl Clone for OpenOptions`

#### `fn clone(&self) -> OpenOptions`

#### `fn clone_from(&mut self, source: &Self)`

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize`)