p1689 0.0.0

Data structures for representing p1689 C++ modules dependency files
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

use indexmap::IndexSet;
use winnow::{
    ascii::multispace0,
    combinator::{delimited, dispatch, empty, fail, peek, trace},
    error::ParserError,
    prelude::*,
    token::{any, literal},
    BStr,
};

use crate::util::winnow::{
    util::{ws_prefix, ws_suffix},
    StateStream,
};

pub fn bool(input: &mut StateStream) -> PResult<bool> {
    dispatch! { any;
        b't' => b"rue".value(true),
        b'f' => b"alse".value(false),
        _ => fail,
    }
    .parse_next(input)
}

pub fn field<'i, 'k, E, K, V, P>(key: &'k K, mut val: P) -> impl Parser<StateStream<'i>, V, E> + 'k
where
    'i: 'k,
    E: ParserError<StateStream<'i>> + 'k,
    K: ?Sized,
    &'k BStr: From<&'k K>,
    V: 'k,
    P: Parser<StateStream<'i>, V, E> + 'k,
{
    let key = Into::<&BStr>::into(key);
    let mut field = move |input: &mut StateStream<'i>| {
        literal(key.as_ref()).parse_next(input)?;
        multispace0.parse_next(input)?;
        b':'.parse_next(input)?;
        multispace0.parse_next(input)?;
        let val = val.parse_next(input)?;
        multispace0.parse_next(input)?;
        dispatch! { peek(any);
            b',' => b','.void(),
            b'}' => empty.value(()),
            _ => fail,
        }
        .parse_next(input)?;
        Ok(val)
    };
    trace("field", move |input: &mut StateStream<'i>| {
        ws_suffix(field.by_ref()).parse_next(input)
    })
}

pub fn record<'i, E, V, P>(mut val: P) -> impl Parser<StateStream<'i>, V, E>
where
    E: ParserError<StateStream<'i>>,
    P: Parser<StateStream<'i>, V, E>,
{
    trace("record", move |input: &mut StateStream<'i>| {
        let val = delimited(b'{', ws_prefix(val.by_ref()), b'}').parse_next(input)?;
        Ok(val)
    })
}

pub fn set<'i, E, V, P>(mut val: P) -> impl Parser<StateStream<'i>, IndexSet<V>, E>
where
    E: ParserError<StateStream<'i>>,
    P: Parser<StateStream<'i>, V, E>,
    V: Eq + core::hash::Hash,
{
    trace("set", move |input: &mut StateStream<'i>| {
        b'['.parse_next(input)?;
        let mut set = IndexSet::default();
        multispace0.parse_next(input)?;
        if b']' != peek(any).parse_next(input)? {
            loop {
                set.insert(val.parse_next(input)?);
                multispace0.parse_next(input)?;
                match any.parse_next(input)? {
                    b',' => multispace0.void().parse_next(input)?,
                    b']' => break,
                    _ => fail.parse_next(input)?,
                }
            }
        } else {
            b']'.parse_next(input)?;
        }
        Ok(set)
    })
}