multiconst_proc_macros 0.2.2

implementation detail of multiconst
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

use alloc::{string::String, vec::Vec};

pub(crate) fn remove_whitespaces(x: &str) -> String {
    x.chars().filter(|x| !x.is_whitespace()).collect()
}

pub trait StrExt {
    fn as_str(&self) -> &str;

    /// Checks that these needles exist consequtively in self.
    ///
    /// Example: `"hello world".consecutive_in_set(&["he", "wor"])` returns `true`.
    /// Example: `"hello world".consecutive_in_set(&["wor", "he"])` returns `false`.
    fn consecutive_in_self<S: AsRef<str>>(&self, needles: &[S]) -> bool {
        let mut rem = self.as_str();
        for needle in needles {
            let needle: &str = needle.as_ref();
            rem = match rem.find(needle) {
                Some(next) => &rem[next + needle.len()..],
                None => return false,
            };
        }
        true
    }

    fn consecutive_unspace(&self, needles: &[&str]) -> bool {
        let rem = remove_whitespaces(self.as_str());
        let needles = needles
            .iter()
            .map(|x| remove_whitespaces(x))
            .collect::<Vec<String>>();
        rem.consecutive_in_self(&needles)
    }
}

impl StrExt for str {
    #[inline(always)]
    fn as_str(&self) -> &str {
        self
    }
}

impl StrExt for alloc::string::String {
    #[inline(always)]
    fn as_str(&self) -> &str {
        self
    }
}