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

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

  /// A trait for converting various types into a reference to a `Path`.
  ///
  /// This trait is used to avoid redundant allocation of memory by providing a reference to a `Path`.
  /// It is implemented only for types that can either be referenced or are references to `Path` itself.
  /// Unlike `TryIntoPath`, it does not allocate memory on the heap. However, `TryIntoPath` is implemented for a wider range of types because it is not restricted from allocating memory.
  /// Unlike `AsRef< Path >`, `AsPath` is implemented for a wider number of types, including those that are not directly convertible to a `Path` using `AsRef`.
  /// This is because `AsPath` is designed to provide a more flexible interface for path-like types, accommodating various representations that can logically be treated as paths.
  pub trait AsPath
  {
  /// Converts the implementing type into a reference to a `Path`.
  ///
  /// # Returns
  ///
  /// A reference to a `Path`.
  fn as_path( &self ) -> &Path;
 }

  /// Implementation of `AsPath` for `str`.
  impl AsPath for str
  {
  fn as_path( &self ) -> &Path
  {
   Path ::new( self )
 }
 }

  /// Implementation of `AsPath` for `Path`.
  impl AsPath for Path
  {
  fn as_path( &self ) -> &Path
  {
   self
 }
 }

  /// Implementation of `AsPath` for `Utf8Path`.
  #[ cfg( feature = "path_utf8" ) ]
  impl AsPath for Utf8Path
  {
  fn as_path( &self ) -> &Path
  {
   self.as_std_path()
 }
 }

  /// Blanket implementation of `AsPath` for all types that implement `AsRef< Path >`.
  impl< T > AsPath for T
  where
  T: AsRef< Path >,
  {
  fn as_path( &self ) -> &Path
  {
   self.as_ref()
 }
 }
}

crate ::mod_interface!
{
  orphan use AsPath;
}