file_type_enum 3.0.0

An enum with a variant for each file type.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

# file_type_enum

An enum with a variant for each file type.

```rust
pub enum FileType {
    Regular,
    Directory,
    Symlink,
    BlockDevice, // unix only
    CharDevice,  // unix only
    Fifo,        // unix only
    Socket,      // unix only
}
```

## Alternatives:

1. If you want a enum tree, check the crate [`fs-tree`](https://docs.rs/fs-tree).
2. If you don't need an enum, check these methods from `std` instead:
    - [`Path::is_file`](https://doc.rust-lang.org/std/path/struct.Path.html#method.is_file).
    - [`Path::is_dir`](https://doc.rust-lang.org/std/path/struct.Path.html#method.is_dir).
    - [`Path::is_symlink`](https://doc.rust-lang.org/std/path/struct.Path.html#method.is_symlink).

## Example:

```rust
use std::{fs, io, path::Path};

use file_type_enum::FileType;

fn move_file(from: &Path, to: &Path) -> io::Result<()> {
    let from_type = FileType::symlink_read_at(from)?;
    let to_type = FileType::symlink_read_at(to)?;

    use FileType::{Directory, Regular, Symlink};

    match (from_type, to_type) {
        (Directory, Directory) => {
            println!("Replacing directory {to:?} by directory {from:?}.");
        }
        (Regular, Regular) | (Symlink, Symlink) => {
            // Might print:
            //       "Overwriting regular file at PATH."
            //       "Overwriting symbolic link at PATH."
            println!("Overwriting {from_type} at {to:?} by {to:?}.");
        }
        (_, Directory) => {
            println!("Moving file at {from:?} into folder {to:?}.");
            fs::rename(from, to)?;
        }
        (_, _) => {
            // Might print:
            // -   "Cannot overwrite regular file  with a symbolic link."
            // -   "Cannot overwrite directory     with a symbolic link."
            // -   "Cannot overwrite symbolic link with a regular file."
            panic!("Cannot overwrite {to_type}     with a {from_type}.");
        }
    }

    Ok(())
}
```

As shown in the example `FileType` also implements `Display`.

## Warning

Note that, like `std` functions, [`FileType::read_at`] follows symlinks, therefore it is
impossible to get the [`FileType::Symlink`] variant. If you want symlink-awareness, use
[`FileType::symlink_read_at`] instead.

## Conversions

- From [`AsRef<Path>`], [`fs::Metadata`] and [std's `FileType`].
- From and into [`libc::mode_t`] (via the feature `"libc"`).


# Feature Flags

- `fs-err`: uses [fs-err] for better IO error messages.
- `libc`: gives libc enum conversions.

[fs-err]: https://docs.rs/fs-err
[`AsRef<Path>`]: https://doc.rust-lang.org/std/path/struct.Path.html
[`FileType::read_at`]: https://docs.rs/file_type_enum/latest/file_type_enum/enum.FileType.html#method.read_at
[`FileType::symlink_read_at`]: https://docs.rs/file_type_enum/latest/file_type_enum/enum.FileType.html#method.symlink_read_at
[`fs::Metadata`]: https://doc.rust-lang.org/std/fs/struct.Metadata.html
[`libc::mode_t`]: https://docs.rs/libc/latest/libc/type.mode_t.html
[std's `FileType`]: https://doc.rust-lang.org/std/fs/struct.FileType.html
[`FileType::Symlink`]: https://docs.rs/file_type_enum/latest/file_type_enum/enum.FileType.html#variant.Symlink