Struct NodeSet 

pub struct NodeSet { /* private fields */ }

A set of syntax parse rules of fixed size.

The set stores all entries in place, and the set object has a fixed size.

The maximum number of rules the object could store is NodeSet::LIMIT.

Most methods of this object are the const functions. Some of them take up to O(LIMIT) and O(LIMIT^2) time to perform.

The object is assumed to be constructed in a const context as a static value upfront to reduce the runtime overhead.

Implementations

impl NodeSet

pub const LIMIT: usize = 16usize

The maximum number of entries this set can address.

This number may be increased in future minor versions of Lady Deirdre.

pub const fn empty() -> Self

Creates a node set without entries.

If you need just a static empty node set, use the predefined EMPTY_NODE_SET static.

pub const fn new(rules: &[NodeRule]) -> Self

Constructs a node set from the slice of the node rules.

Panic

Panics if the rules parameter has more than the LIMIT number of unique node rules.

Panics if any value within the rules slice is a NON_RULE.

pub const fn contains(&self, rule: NodeRule) -> bool

Returns true if the node set contains the specified node rule.

pub const fn include(self, rule: NodeRule) -> Self

Consumes this NodeSet instance and returns a new node set that includes the rule node rule.

Panic

Panics if the rule argument is a NON_RULE.

Panics if the node set already has a LIMIT number of unique entries, and the rule argument is a new entry within this set.

pub const fn include_all(self, rules: &[NodeRule]) -> Self

Consumes this NodeSet instance and returns a new node set that includes all node rules from the rules slice.

Panic

Panics if any rule number within the slice argument is a NON_RULE.

Panics if the total number if unique entries within this node set and the rules from the rules slice exceeds LIMIT.

pub const fn exclude(self, rule: NodeRule) -> Self

Consumes this NodeSet instance and returns a new node set without the specified rule node rule.

pub const fn exclude_all(self, rules: &[NodeRule]) -> Self

Consumes this NodeSet instance and returns a new node set without the entries specified in the rules node rule slice.

pub const fn is_empty(&self) -> bool

Returns true if the NodeSet has no entries.

pub const fn len(&self) -> usize

Returns the number of entries in this NodeSet instance.

pub fn display<N: AbstractNode>(&self) -> impl Debug + Display + '_

Returns an object that displays all entries within this node set.

The N generic parameter specifies the syntax grammar of the programming language (see Node).

The underlying displaying algorithm uses the rule_name function to determine the rules’ display names.

Trait Implementations

impl Clone for NodeSet

fn clone(&self) -> NodeSet

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for NodeSet

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for NodeSet

fn default() -> NodeSet

Returns the “default value” for a type.

impl FromIterator<u16> for NodeSet

fn from_iter<I: IntoIterator<Item = NodeRule>>(iter: I) -> Self

Creates a value from an iterator.

impl<'set> IntoIterator for &'set NodeSet

type Item = u16

The type of the elements being iterated over.

type IntoIter = NodeSetIter<'set>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq for NodeSet

fn eq(&self, other: &NodeSet) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for NodeSet

impl Eq for NodeSet

impl StructuralPartialEq for NodeSet