rpsl 0.1.1

A parser for the Routing Policy Specification Language (RPSL)
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

use std::fmt;

#[cfg(any(test, feature = "arbitrary"))]
use proptest::{arbitrary::ParamsFor, prelude::*};

use crate::{
    error::{ParseError, ParseResult},
    parser::TokenPair,
};

/// Ordered list of RPSL expressions or names. See [RFC2622].
///
/// [RFC2622]: https://datatracker.ietf.org/doc/html/rfc2622#section-2
#[derive(Clone, Debug, Hash, PartialEq, Eq)]
pub struct ListOf<T>(Vec<T>);

impl<T> FromIterator<T> for ListOf<T> {
    fn from_iter<I>(iter: I) -> Self
    where
        I: IntoIterator<Item = T>,
    {
        Self(iter.into_iter().collect())
    }
}

impl<'a, T> TryFrom<TokenPair<'a>> for ListOf<T>
where
    T: TryFrom<TokenPair<'a>, Error = ParseError>,
{
    type Error = ParseError;

    fn try_from(pair: TokenPair<'a>) -> ParseResult<Self> {
        pair.into_inner().map(T::try_from).collect()
    }
}

impl<T> fmt::Display for ListOf<T>
where
    T: fmt::Display,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.0
            .iter()
            .map(T::to_string)
            .collect::<Vec<String>>()
            .join(", ")
            .fmt(f)
    }
}

#[cfg(any(test, feature = "arbitrary"))]
impl<T> Arbitrary for ListOf<T>
where
    T: Arbitrary,
    T::Strategy: 'static,
{
    type Parameters = ParamsFor<T>;
    type Strategy = BoxedStrategy<Self>;
    fn arbitrary_with(params: Self::Parameters) -> Self::Strategy {
        proptest::collection::vec(any_with::<T>(params), 1..8)
            .prop_map(|v| v.into_iter().collect())
            .boxed()
    }
}