Trait AtRuleParser 

pub trait AtRuleParser<'i>: Sized {
    type Prelude;
    type AtRule;
    type Error: 'i;

    // Provided methods
    fn parse_prelude<'t>(
        &mut self,
        name: CowRcStr<'i>,
        input: &mut Parser<'i, 't>,
        options: &ParserOptions<'i>,
    ) -> Result<Self::Prelude, ParseError<'i, Self::Error>> { ... }
    fn rule_without_block(
        &mut self,
        prelude: Self::Prelude,
        start: &ParserState,
        options: &ParserOptions<'i>,
        is_nested: bool,
    ) -> Result<Self::AtRule, ()> { ... }
    fn parse_block<'t>(
        &mut self,
        prelude: Self::Prelude,
        start: &ParserState,
        input: &mut Parser<'i, 't>,
        options: &ParserOptions<'i>,
        is_nested: bool,
    ) -> Result<Self::AtRule, ParseError<'i, Self::Error>> { ... }
}

A trait to provide parsing of custom at-rules.

For example, there could be different implementations for top-level at-rules (@media, @font-face, …) and for page-margin rules inside @page.

Default implementations that reject all at-rules are provided, so that impl AtRuleParser<(), ()> for ... {} can be used for using DeclarationListParser to parse a declarations list with only qualified rules.

Note: this trait is copied from cssparser and modified to provide parser options.

Required Associated Types

type Prelude

The intermediate representation of prelude of an at-rule.

type AtRule

The finished representation of an at-rule.

type Error: 'i

The error type that is included in the ParseError value that can be returned.

Provided Methods

fn parse_prelude<'t>( &mut self, name: CowRcStr<'i>, input: &mut Parser<'i, 't>, options: &ParserOptions<'i>, ) -> Result<Self::Prelude, ParseError<'i, Self::Error>>

Parse the prelude of an at-rule with the given name.

Return the representation of the prelude and the type of at-rule, or Err(()) to ignore the entire at-rule as invalid.

The prelude is the part after the at-keyword and before the ; semicolon or { /* ... */ } block.

At-rule name matching should be case-insensitive in the ASCII range. This can be done with std::ascii::Ascii::eq_ignore_ascii_case, or with the match_ignore_ascii_case! macro.

The given input is a “delimited” parser that ends wherever the prelude should end. (Before the next semicolon, the next {, or the end of the current block.)

fn rule_without_block( &mut self, prelude: Self::Prelude, start: &ParserState, options: &ParserOptions<'i>, is_nested: bool, ) -> Result<Self::AtRule, ()>

End an at-rule which doesn’t have block. Return the finished representation of the at-rule.

The location passed in is source location of the start of the prelude. is_nested indicates whether the rule is nested inside a style rule.

This is only called when either the ; semicolon indeed follows the prelude, or parser is at the end of the input.

fn parse_block<'t>( &mut self, prelude: Self::Prelude, start: &ParserState, input: &mut Parser<'i, 't>, options: &ParserOptions<'i>, is_nested: bool, ) -> Result<Self::AtRule, ParseError<'i, Self::Error>>

Parse the content of a { /* ... */ } block for the body of the at-rule.

The location passed in is source location of the start of the prelude. is_nested indicates whether the rule is nested inside a style rule.

Return the finished representation of the at-rule as returned by RuleListParser::next or DeclarationListParser::next, or Err(()) to ignore the entire at-rule as invalid.

This is only called when a block was found following the prelude.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors