minxp 0.1.7

Partial reimplementation of std for no-std on unsupported Windows targets.
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

use alloc::string::String;
use core::fmt::{Display, Formatter};
use core::marker::PhantomData;
use crate::ffi::{OsStr, OsString};
use crate::path::PathBuf;

#[derive(Debug)]
pub struct JoinPathsError {
    phantom_data: PhantomData<()>
}

impl Display for JoinPathsError {
    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
        f.write_str("an error occurred when joining paths")
    }
}

pub fn join_paths<I: Iterator<Item = T>, T: AsRef<OsStr>>(paths: I) -> Result<OsString, JoinPathsError> {
    let mut s = String::new();
    for i in paths {
        let path_str = i.as_ref().as_str();

        if path_str.contains('"') {
            return Err(JoinPathsError { phantom_data: PhantomData });
        }

        if s.is_empty() {
            s += ";"
        }

        if path_str.contains(';') {
            s += "\"";
            s += path_str;
            s += "\"";
        }
        else {
            s += path_str;
        }
    }

    Ok(s.into())
}

pub fn split_paths<T: AsRef<OsStr> + ?Sized>(unparsed: &T) -> SplitPaths<'_> {
    SplitPaths {
        path_data: Some(unparsed.as_ref().as_str())
    }
}

pub struct SplitPaths<'a> {
    path_data: Option<&'a str>
}

impl<'a> Iterator for SplitPaths<'a> {
    type Item = PathBuf;
    fn next(&mut self) -> Option<Self::Item> {
        let string = self.path_data?;

        let string_found;
        let mut current_offset = 0usize;

        loop {
            let search_string = &string[current_offset..];

            let Some(next_semicolon) = search_string.find(';') else {
                // last string
                string_found = string;
                self.path_data = None;
                break;
            };

            match search_string.find('"') {
                Some(next_quote) if next_quote < next_semicolon => {
                    current_offset += next_quote + 1;
                    let remaining = &string[current_offset..];
                    let Some(end) = remaining.find('"') else {
                        // no quote to terminate, so last string
                        string_found = string;
                        self.path_data = None;
                        break;
                    };
                    current_offset += end + 1;
                },
                _ => {
                    let end = current_offset + next_semicolon;
                    let (a, b) = string.split_at(end);
                    string_found = a;
                    self.path_data = Some(&b[1..]);
                    break;
                }
            }
        }

        let found_string = string_found.replace('"', "");
        Some(PathBuf::from_string(found_string))
    }
}

#[cfg(test)]
mod test;