Struct jql::Group

source ·

pub struct Group {
    pub filters: Vec<Filter>,
    pub root: Option<()>,
    pub selectors: Vec<Selector>,
    pub spread: Option<()>,
    pub truncate: Option<()>,
}

Expand description

A Group is a set of grammar elements used to define a selection.

Fields§

§filters: Vec<Filter>

Filters.

§root: Option<()>

Root marker.

§selectors: Vec<Selector>

Selectors.

§spread: Option<()>

Spread marker.

§truncate: Option<()>

Truncate marker.

Implementations§

source §

impl Group

Group implementations.

source

pub fn new() -> Self

Creates a new group.

Examples found in repository ?

src/types.rs (line 106)

105
106
107

    fn default() -> Self {
        Self::new()
    }

More examples

Hide additional examples

src/parser.rs (line 144)

pub fn selectors_parser(selectors: &str) -> Result<Vec<Group>, String> {
    match GroupsParser::parse(Rule::groups, selectors) {
        Ok(pairs) => {
            let mut groups: Vec<Group> = Vec::new();

            for pair in pairs {
                let mut group = Group::new();

                // Loop over the pairs converted as an iterator of the tokens
                // which composed it.
                for inner_pair in pair.into_inner() {
                    let inner_span = inner_pair.clone().as_span().as_str();

                    // Populate the group based on the rules found by the
                    // parser.
                    match inner_pair.as_rule() {
                        // Default
                        Rule::default => group
                            .selectors
                            .push(span_to_default(&get_chars_from_pair(inner_pair)[0].clone())),
                        Rule::filter_default => {
                            group.filters.push(Filter::Default(span_to_default(
                                &get_chars_from_pair(inner_pair.into_inner().next().unwrap())[0]
                                    .clone(),
                            )))
                        }

                        // Index
                        Rule::index => group.selectors.push(span_to_index(inner_span)),
                        Rule::filter_index => group
                            .filters
                            .push(Filter::Default(span_to_index(inner_span))),

                        // Range
                        Rule::range => group.selectors.push(span_to_range(inner_pair)),
                        Rule::filter_range => group.filters.push(Filter::Default(span_to_range(
                            inner_pair.into_inner().next().unwrap(),
                        ))),

                        // Property
                        Rule::property => group
                            .selectors
                            .push(Selector::Object(get_inner_object_from_pair(inner_pair))),
                        Rule::filter_property => group.filters.push(Filter::Default(
                            Selector::Object(get_inner_object_from_pair(inner_pair)),
                        )),

                        // Filter lens property.
                        Rule::filter_lens_property => group.filters.push(Filter::Lens(
                            Selector::Object(get_inner_object_from_pair(inner_pair)),
                        )),

                        // Root
                        Rule::root => group.root = Some(()),

                        // Spread
                        Rule::spread => group.spread = Some(()),

                        // Truncate
                        Rule::truncate => group.truncate = Some(()),
                        _ => (),
                    };
                }

                // Add the group.
                groups.push(group);
            }

            Ok(groups)
        }
        Err(_) => Err(String::from("Error, unable to parse invalid selectors")),
    }
}