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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172

use std::convert::TryFrom;
use std::{env, io};

use crate::{NativePathBuf, Utf8NativePathBuf};

/// Returns the current working directory as [`NativePathBuf`].
///
/// # Errors
///
/// Returns an [`Err`] if the current working directory value is invalid
/// or unable to parse the directory with the native encoding.
///
/// Possible cases:
///
/// * Current directory does not exist.
/// * There are insufficient permissions to access the current directory.
/// * The encoding used to parse the current directory failed to parse.
///
/// # Examples
///
/// ```
/// fn main() -> std::io::Result<()> {
///     let path = typed_path::utils::current_dir()?;
///     println!("The current directory is {}", path.display());
///     Ok(())
/// }
/// ```
pub fn current_dir() -> io::Result<NativePathBuf> {
    let std_path = env::current_dir()?;
    match NativePathBuf::try_from(std_path) {
        Ok(path) => Ok(path),
        _ => Err(io::Error::new(io::ErrorKind::InvalidData, "wrong encoding")),
    }
}

/// Returns the current working directory as [`Utf8NativePathBuf`].
///
/// # Errors
///
/// Returns an [`Err`] if the current working directory value is invalid
/// or unable to parse the directory with the native encoding.
///
/// Possible cases:
///
/// * Current directory does not exist.
/// * There are insufficient permissions to access the current directory.
/// * The encoding used to parse the current directory failed to parse.
/// * The current directory was not valid UTF8.
///
/// # Examples
///
/// ```
/// fn main() -> std::io::Result<()> {
///     let path = typed_path::utils::utf8_current_dir()?;
///     println!("The current directory is {}", path);
///     Ok(())
/// }
/// ```
pub fn utf8_current_dir() -> io::Result<Utf8NativePathBuf> {
    match Utf8NativePathBuf::from_bytes_path_buf(current_dir()?) {
        Ok(path) => Ok(path),
        Err(x) => Err(io::Error::new(io::ErrorKind::InvalidData, x)),
    }
}

/// Returns the full filesystem path of the current running executable as [`NativePathBuf`].
///
/// # Errors
///
/// Returns an [`Err`] if unable to parse the path with the native encoding.
///
/// Additionally, returns a [`Err`] if, as [`env::current_exe`] states,
/// a related filesystem operation or syscall fails.
///
///
/// # Examples
///
/// ```
/// fn main() -> std::io::Result<()> {
///     let path = typed_path::utils::current_exe()?;
///     println!("The current executable path is {}", path.display());
///     Ok(())
/// }
/// ```
pub fn current_exe() -> io::Result<NativePathBuf> {
    let std_current_exe = env::current_exe()?;

    match NativePathBuf::try_from(std_current_exe) {
        Ok(path) => Ok(path),
        Err(_) => Err(io::Error::new(io::ErrorKind::InvalidData, "wrong encoding")),
    }
}

/// Returns the full filesystem path of the current running executable as [`Utf8NativePathBuf`].
///
/// # Errors
///
/// Returns an [`Err`] if unable to parse the path with the native encoding
/// or the path was not valid UTF8.
///
/// Additionally, returns a [`Err`] if, as [`env::current_exe`] states,
/// a related filesystem operation or syscall fails.
///
///
/// # Examples
///
/// ```
/// fn main() -> std::io::Result<()> {
///     let path = typed_path::utils::utf8_current_exe()?;
///     println!("The current executable path is {}", path);
///     Ok(())
/// }
/// ```
pub fn utf8_current_exe() -> io::Result<Utf8NativePathBuf> {
    let typed_current_exe = current_exe()?;

    match Utf8NativePathBuf::from_bytes_path_buf(typed_current_exe) {
        Ok(path) => Ok(path),
        Err(error) => Err(io::Error::new(io::ErrorKind::InvalidData, error)),
    }
}

/// Returns the path of a temporary directory as [`NativePathBuf`].
///
/// # Errors
///
/// Returns an [`Err`] if unable to parse the path with the native encoding.
///
///
/// # Examples
///
/// ```
/// fn main() -> std::io::Result<()> {
///     let path = typed_path::utils::temp_dir()?;
///     println!("The temporary directory path is {}", path.display());
///     Ok(())
/// }
/// ```
pub fn temp_dir() -> io::Result<NativePathBuf> {
    let std_temp_dir = env::temp_dir();

    match NativePathBuf::try_from(std_temp_dir) {
        Ok(path) => Ok(path),
        Err(_) => Err(io::Error::new(io::ErrorKind::InvalidData, "wrong encoding")),
    }
}

/// Returns the path of a temporary directory as [`Utf8NativePathBuf`].
///
/// # Errors
///
/// Returns an [`Err`] if unable to parse the path with the native encoding
/// or the path was not valid UTF8.
///
///
/// # Examples
///
/// ```
/// fn main() -> std::io::Result<()> {
///     let path = typed_path::utils::utf8_temp_dir()?;
///     println!("The temporary directory path is {}", path);
///     Ok(())
/// }
/// ```
pub fn utf8_temp_dir() -> io::Result<Utf8NativePathBuf> {
    let typed_temp_dir = temp_dir()?;

    match Utf8NativePathBuf::from_bytes_path_buf(typed_temp_dir) {
        Ok(path) => Ok(path),
        Err(error) => Err(io::Error::new(io::ErrorKind::InvalidData, error)),
    }
}