cross-path 0.0.1

Advanced cross-platform path handling library for Windows/Linux path conversion
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

use std::fmt;

/// Path error type
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum PathError {
    /// Invalid path
    InvalidPath(String),

    /// Encoding error
    EncodingError(String),

    /// Security error
    SecurityError(String),

    /// Platform-specific error
    PlatformError(String),

    /// Path normalization error
    NormalizationError(String),

    /// Path parsing error
    ParseError(String),

    /// IO error
    IoError(String),

    /// Unsupported path format
    UnsupportedFormat(String),

    /// Drive mapping error
    DriveMappingError(String),
}

impl PathError {
    /// Create new `InvalidPath` error
    pub fn invalid_path(msg: impl Into<String>) -> Self {
        Self::InvalidPath(msg.into())
    }

    /// Create new `EncodingError`
    pub fn encoding_error(msg: impl Into<String>) -> Self {
        Self::EncodingError(msg.into())
    }

    /// Create new `SecurityError`
    pub fn security_error(msg: impl Into<String>) -> Self {
        Self::SecurityError(msg.into())
    }

    /// Create new `PlatformError`
    pub fn platform_error(msg: impl Into<String>) -> Self {
        Self::PlatformError(msg.into())
    }
}

impl fmt::Display for PathError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::InvalidPath(msg) => write!(f, "Invalid path: {msg}"),
            Self::EncodingError(msg) => write!(f, "Encoding error: {msg}"),
            Self::SecurityError(msg) => write!(f, "Security error: {msg}"),
            Self::PlatformError(msg) => write!(f, "Platform error: {msg}"),
            Self::NormalizationError(msg) => write!(f, "Normalization error: {msg}"),
            Self::ParseError(msg) => write!(f, "Parse error: {msg}"),
            Self::IoError(msg) => write!(f, "IO error: {msg}"),
            Self::UnsupportedFormat(msg) => write!(f, "Unsupported format: {msg}"),
            Self::DriveMappingError(msg) => write!(f, "Drive mapping error: {msg}"),
        }
    }
}

impl std::error::Error for PathError {}

impl From<std::io::Error> for PathError {
    fn from(err: std::io::Error) -> Self {
        Self::IoError(err.to_string())
    }
}