Struct ReprParserMultiple

pub struct ReprParserMultiple<'a> {
    pub bytes: Bytes<'a>,
}

Fields

bytes: Bytes<'a>

Implementations

impl<'a> ReprParserMultiple<'a>

pub fn new(input: &'a str) -> Self

pub fn is_next_duration(byte: u8) -> bool

pub fn try_consume_connection( &mut self, delimiter: Delimiter, conjunctions: &'a [&'a str], ) -> Result<(), ParseError>

Trait Implementations

impl<'a> ReprParserTemplate<'a> for ReprParserMultiple<'a>

type Output = (DurationRepr<'a>, Option<&'a mut ReprParserMultiple<'a>>)

fn bytes(&mut self) -> &mut Bytes<'a>

fn make_output(&'a mut self, duration_repr: DurationRepr<'a>) -> Self::Output

fn parse_infinity_remainder( &'a mut self, duration_repr: DurationRepr<'a>, config: &'a Config<'_>, ) -> Result<(DurationRepr<'a>, Option<&'a mut ReprParserMultiple<'a>>), ParseError>

fn parse_keyword( &mut self, keywords: Option<&dyn TimeUnitsLike>, config: &'a Config<'_>, ) -> Result<Option<(TimeUnit, Multiplier)>, ParseError>

fn parse_time_unit( &mut self, config: &'a Config<'_>, time_units: &dyn TimeUnitsLike, ) -> Result<Option<(TimeUnit, Multiplier)>, ParseError>

fn parse_number_time_unit( &mut self, duration_repr: &mut DurationRepr<'a>, config: &'a Config<'_>, time_units: &dyn TimeUnitsLike, ) -> Result<bool, ParseError>

fn finalize( &'a mut self, duration_repr: DurationRepr<'a>, config: &'a Config<'_>, ) -> Result<Self::Output, ParseError>

fn parse_whole(&mut self) -> Whole

fn parse_numeral( &mut self, numerals: Option<&'a dyn NumbersLike>, config: &'a Config<'_>, ) -> Result<Option<(&'a str, Multiplier)>, ParseError>

fn parse( &'a mut self, config: &'a Config<'_>, time_units: &dyn TimeUnitsLike, keywords: Option<&dyn TimeUnitsLike>, numerals: Option<&'a dyn NumbersLike>, ) -> Result<Self::Output, ParseError>

fn parse_sign_is_negative(&mut self) -> Result<Option<bool>, ParseError>

Parse and consume the sign if present. Return true if sign is negative.

fn parse_number_sign( &mut self, duration_repr: &mut DurationRepr<'_>, config: &Config<'_>, ) -> Result<(), ParseError>

fn parse_fract(&mut self) -> Fract

fn parse_number_fraction( &mut self, duration_repr: &mut DurationRepr<'a>, disable_fraction: bool, ) -> Result<bool, ParseError>

fn parse_exponent(&mut self) -> Result<i16, ParseError>

fn parse_number_exponent( &mut self, duration_repr: &mut DurationRepr<'a>, disable_exponent: bool, ) -> Result<bool, ParseError>

fn parse_number_delimiter( &mut self, delimiter: Option<Delimiter>, ) -> Result<bool, ParseError>