pth 0.36.0

Collection of algorithms and structures to handle paths properly.
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
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

/// Define a private namespace for all its items.
mod private
{
  #[ allow( unused_imports, clippy ::wildcard_imports ) ]
  use crate :: *;
  use std ::
  {
  io,
  path :: { Component, Path, PathBuf },
  string ::String,
 };

  /// A trait for converting various types into a `PathBuf`.
  ///
  /// This trait is used to convert any path-like type into an owned `PathBuf`.
  /// Unlike `TryIntoCowPath`, it always returns an owned `PathBuf`, so there is no need to differentiate between borrowed and owned paths at runtime.
  /// Unlike `AsPath`, it is implemented for a wider range of path-like types, similar to `TryIntoCowPath`.
  pub trait TryIntoPath
  {
  /// Converts the implementing type into a `PathBuf`.
  ///
  /// # Returns
  ///
  /// * `Ok(PathBuf)` - The owned path buffer.
  /// * `Err(io ::Error)` - An error if the conversion fails.
  ///
  /// # Errors
  ///
  /// Currently, all standard implementations (`&str`, `String`, `PathBuf`, `&Path`, `Component`,
  /// and types implementing `AsRef<Path>`) never return an error - they always succeed. The `Result`
  /// return type is maintained for:
  /// - API consistency with `TryIntoCowPath` and other fallible conversions
  /// - Future implementations that may need to validate or transform paths
  /// - Custom types that may have fallible path conversions
  fn try_into_path( self ) -> Result< PathBuf, io ::Error >;
 }

  /// Implementation of `TryIntoPath` for `&str`.
  impl TryIntoPath for &str
  {
  fn try_into_path( self ) -> Result< PathBuf, io ::Error >
  {
   Ok( PathBuf ::from( self ) )
 }
 }

  /// Implementation of `TryIntoPath` for `String`.
  impl TryIntoPath for String
  {
  fn try_into_path( self ) -> Result< PathBuf, io ::Error >
  {
   Ok( PathBuf ::from( self ) )
 }
 }

  /// Implementation of `TryIntoPath` for a reference to `Path`.
  impl TryIntoPath for &Path
  {
  fn try_into_path( self ) -> Result< PathBuf, io ::Error >
  {
   Ok( self.to_path_buf() )
 }
 }

  /// Implementation of `TryIntoPath` for `PathBuf`.
  impl TryIntoPath for PathBuf
  {
  fn try_into_path( self ) -> Result< PathBuf, io ::Error >
  {
   Ok( self )
 }
 }

  /// Implementation of `TryIntoPath` for a reference to `Utf8Path`.
  #[ cfg( feature = "path_utf8" ) ]
  impl TryIntoPath for &Utf8Path
  {
  fn try_into_path( self ) -> Result< PathBuf, io ::Error >
  {
   Ok( self.as_std_path().to_path_buf() )
 }
 }

  /// Implementation of `TryIntoPath` for `Utf8PathBuf`.
  #[ cfg( feature = "path_utf8" ) ]
  impl TryIntoPath for Utf8PathBuf
  {
  fn try_into_path( self ) -> Result< PathBuf, io ::Error >
  {
   Ok( self.as_std_path().to_path_buf() )
 }
 }

  /// Implementation of `TryIntoPath` for `std ::path ::Component`.
  impl TryIntoPath for Component< '_ >
  {
  fn try_into_path( self ) -> Result< PathBuf, io ::Error >
  {
   Ok( self.as_os_str().into() )
 }
 }

  /// Blanket implementation of `TryIntoPath` for references to types implementing `AsRef< Path >`.
  impl< T > TryIntoPath for &T
  where
  T: AsRef< Path >,
  {
  fn try_into_path( self ) -> Result< PathBuf, io ::Error >
  {
   Ok( self.as_ref().to_path_buf() )
 }
 }
}

crate ::mod_interface!
{
  orphan use TryIntoPath;
}