rust-parser-combinator/src/combinators/separated_by.rs

use crate::combinators::repeated::Repeated;
use crate::parser::{BoxedParser, ParseResult, Parser, ParserInput, Representation};

pub struct SeparatedBy<'a, I, O>
where
    I: ParserInput + Clone,
{
    pub(super) inner_repeated: Repeated<'a, I, O>,
    pub(super) delimiter: BoxedParser<'a, I, (), I>,
    pub(super) allow_trailing: bool,
}

impl<'a, I, O> Parser<I, Vec<O>, I> for SeparatedBy<'a, I, O>
where
    I: ParserInput + Clone + 'a,
{
    fn representation(&self) -> Representation {
        Representation::new("NOT IMPL'D")
    }

    fn parse(&self, input: I) -> ParseResult<I, Vec<O>, I> {
        let at_least = self.inner_repeated.at_least.unwrap_or(0);
        let at_most = self.inner_repeated.at_most.unwrap_or(u16::MAX);
        let parser = &self.inner_repeated.inner_parser;
        let delimiter = &self.delimiter;

        if at_most == 0 {
            return Ok((vec![], input));
        }

        let mut results = Vec::new();
        let mut count: u16 = 0;
        let mut further_input;

        match parser.parse(input.clone()) {
            Ok((item, rest)) => {
                results.push(item);
                further_input = rest;
            }
            Err(_e) => {
                if at_least > 0 {
                    return Err(input);
                } else {
                    return Ok((vec![], input));
                }
            }
        }

        loop {
            match delimiter.parse(further_input.clone()) {
                Ok(((), rest)) => {
                    further_input = rest;
                }
                Err(_e) => {
                    break;
                }
            }

            match parser.parse(further_input.clone()) {
                Ok((item, rest)) => {
                    results.push(item);
                    further_input = rest;
                    count += 1;
                }
                Err(_e) if self.allow_trailing => {
                    break;
                }
                Err(e) => {
                    return Err(e);
                }
            }

            if count >= at_most {
                break;
            }
        }

        if count < at_least {
            return Err(input);
        }

        Ok((results, further_input))
    }
}