algosul-core 0.0.5

Some user-friendly yet personalized tools
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
119
120
121
122
123
124
125
126
127

use std::{
  borrow::Cow,
  ffi::{OsStr, OsString},
};

#[macro_export]
macro_rules! cows {
  [] => {
    []
  };
  [$($elem:expr),+ $(,)?] => {
    [
      $(
        $crate::cow!($elem)
      ),+
    ]
  };
  [$elem:expr; $n:expr] => (
    [$crate::cow!($elem); $n]
  );
}
#[macro_export]
macro_rules! cow {
  ($expr:expr) => {
    ::std::borrow::Cow::<'_, _>::from($expr)
  };
}
pub trait MapToArg<'b>
{
  fn map_to_arg(self) -> Cow<'b, OsStr>;
}
pub trait MapToArgs<'b>
{
  fn map_to_args(self) -> impl Iterator<Item = Cow<'b, OsStr>>;
}

/// [issue: #1958](https://github.com/rust-lang/reference/issues/1958)
pub trait CowExt<'a, T: ?Sized + ToOwned + 'a>
{
  fn map_ref_or_owned<'b, U: ?Sized + ToOwned, B, O>(
    self, b: B, o: O,
  ) -> Cow<'b, U>
  where
    B: FnOnce(&'a T) -> &'b U,
    O: FnOnce(T::Owned) -> U::Owned;
  fn map_to_cow<'b, U: ?Sized + ToOwned, B, O>(self, b: B, o: O) -> Cow<'b, U>
  where
    B: FnOnce(&'a T) -> Cow<'b, U>,
    O: FnOnce(T::Owned) -> Cow<'b, U>;
}
impl<'a, T: ?Sized + ToOwned> CowExt<'a, T> for Cow<'a, T>
{
  #[inline]
  fn map_ref_or_owned<'b, U: ?Sized + ToOwned, B, O>(
    self, b: B, o: O,
  ) -> Cow<'b, U>
  where
    B: FnOnce(&'a T) -> &'b U,
    O: FnOnce(T::Owned) -> U::Owned,
  {
    match self
    {
      Cow::Borrowed(borrow) => Cow::Borrowed(b(borrow)),
      Cow::Owned(owned) => Cow::Owned(o(owned)),
    }
  }

  #[inline]
  fn map_to_cow<'b, U: ?Sized + ToOwned, B, O>(self, b: B, o: O) -> Cow<'b, U>
  where
    B: FnOnce(&'a T) -> Cow<'b, U>,
    O: FnOnce(T::Owned) -> Cow<'b, U>,
  {
    match self
    {
      Cow::Borrowed(borrow) => b(borrow),
      Cow::Owned(owned) => o(owned),
    }
  }
}
impl<'a: 'b, 'b, S> MapToArg<'b> for Cow<'a, S>
where
  S: ?Sized + ToOwned + AsRef<OsStr> + 'a,
  S::Owned: Into<OsString>,
{
  #[inline]
  fn map_to_arg(self) -> Cow<'b, OsStr>
  {
    self.map_ref_or_owned(OsStr::new, Into::into)
  }
}
impl<'a: 'b, 'b, T, S> MapToArgs<'b> for T
where
  S: ?Sized + ToOwned + AsRef<OsStr> + 'a,
  S::Owned: Into<OsString>,
  T: IntoIterator<Item = Cow<'a, S>>,
{
  #[inline]
  fn map_to_args(self) -> impl Iterator<Item = Cow<'b, OsStr>>
  {
    self.into_iter().map(MapToArg::map_to_arg)
  }
}

#[cfg(test)]
mod tests
{
  use std::ffi::OsStr;

  use super::*;
  #[test]
  fn test_demo()
  {
    demo("test");
  }

  fn demo(input: &str)
  {
    let cow: Cow<'_, str> = Cow::Borrowed(input);

    {
      let result: Cow<'_, OsStr> = cow.map_ref_or_owned(OsStr::new, Into::into);

      println!("{:?}", result);
    }
  }
}