Struct RuleMap

pub struct RuleMap<Q, S>
where
    Q: RawState + Eq + Hash,
    S: Eq + Hash,
{ /* private fields */ }

Implementations

impl<Q, S> RuleMap<Q, S>

where Q: RawState + Eq + Hash, S: Eq + Hash,

pub fn new() -> Self

pub fn from_state(initial_state: State<Q>) -> Self

pub fn from_iter<I>(iter: I) -> Self

where I: IntoIterator<Item = (Head<Q, S>, Tail<Q, S>)>,

pub fn from_rules<I>(iter: I) -> Self

where I: IntoIterator<Item = Rule<Q, S>>,

pub fn with_initial_state(self, state: State<Q>) -> Self

configures the ruleset with the given initial state

pub fn with_instructions( self, instructions: impl IntoIterator<Item = (Head<Q, S>, Tail<Q, S>)>, ) -> Self

pub fn initial_state(&self) -> Option<State<&Q>>

returns an instance of State which owns a reference to the interval value.

pub const fn rules(&self) -> &HashMap<Head<Q, S>, Tail<Q, S>>

returns an immutable reference to the set of rules.

pub const fn rules_mut(&mut self) -> &mut HashMap<Head<Q, S>, Tail<Q, S>>

returns a mutable reference to the set of rules.

pub fn clear(&mut self)

Clears the set of rules.

pub fn rule(&mut self, head: Head<Q, S>) -> Entry<'_, Head<Q, S>, Tail<Q, S>>

returns an the entry for the given head within the set of rules.

pub fn get_head<K>(&self, head: &K) -> Option<&Tail<Q, S>>

where K: Eq + Hash, Head<Q, S>: Borrow<K>,

returns an immutable reference to the tail of the rule for the given head; returns none if the head is not found.

pub fn get_mut<K>(&mut self, head: &K) -> Option<&mut Tail<Q, S>>

where K: Eq + Hash, Head<Q, S>: Borrow<K>,

returns a mutable reference to the tail of the rule for the given head; returns none if the head is not found.

pub fn get_ref<K>(&self, head: &K) -> Option<Tail<&Q, &S>>

where K: Eq + Hash, Head<Q, S>: Borrow<K>,

returns the tail of the rule for the given head; returns none if the head is not found within the set of rules.

pub fn insert(&mut self, head: Head<Q, S>, tail: Tail<Q, S>)

where Q: RawState + Eq + Hash, S: Eq + Hash,

insert a new rule into the set of rules.

pub fn insert_rule(&mut self, rule: Rule<Q, S>)

where Q: RawState + Eq + Hash, S: Eq + Hash,

insert a new rule into the set of rules.

pub fn is_empty(&self) -> bool

returns true if the set of rules is empty.

pub fn len(&self) -> usize

returns the number of rules in the set.

pub fn or_insert( &mut self, head: Head<Q, S>, tail: Tail<Q, S>, ) -> &mut Tail<Q, S>

returns a mutable reference to the tail of the rule for the given head; inserts the tail if the head is not found.

pub fn or_insert_with<F>(&mut self, head: Head<Q, S>, f: F) -> &mut Tail<Q, S>

where F: FnOnce() -> Tail<Q, S>,

returns a mutable reference to the tail of the rule for the given head; inserts the tail if the head is not found.

pub fn or_insert_default(&mut self, head: Head<Q, S>) -> &mut Tail<Q, S>

where Q: Default, S: Default,

returns a mutable reference to the tail of the rule for the given head; inserts the default tail if the head is not found.

pub fn remove(&mut self, head: &Head<Q, S>) -> Option<Tail<Q, S>>

Removes a rule from the set of rules.

Trait Implementations

impl<Q, S> Clone for RuleMap<Q, S>

where Q: RawState + Eq + Hash + Clone, S: Eq + Hash + Clone,

fn clone(&self) -> RuleMap<Q, S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Q, S> Debug for RuleMap<Q, S>

where Q: RawState + Eq + Hash + Debug, S: Eq + Hash + Debug,

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

Formats the value using the given formatter.

impl<Q, S> Default for RuleMap<Q, S>

where Q: RawState + Eq + Hash + Default, S: Eq + Hash + Default,

fn default() -> RuleMap<Q, S>

Returns the “default value” for a type.

impl<Q, S> Extend<(Head<Q, S>, Tail<Q, S>)> for RuleMap<Q, S>

where Q: RawState + Eq + Hash, S: Eq + Hash,

fn extend<I>(&mut self, iter: I)

where I: IntoIterator<Item = (Head<Q, S>, Tail<Q, S>)>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<Q, S> Extend<Rule<Q, S>> for RuleMap<Q, S>

where Q: RawState + Eq + Hash, S: Eq + Hash,

fn extend<I>(&mut self, iter: I)

where I: IntoIterator<Item = Rule<Q, S>>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<Q, S> FromIterator<(Head<Q, S>, Tail<Q, S>)> for RuleMap<Q, S>

where Q: RawState + Default + Eq + Hash, S: Eq + Hash,

fn from_iter<I>(iter: I) -> Self

where I: IntoIterator<Item = (Head<Q, S>, Tail<Q, S>)>,

Creates a value from an iterator.

impl<Q, S> FromIterator<Rule<Q, S>> for RuleMap<Q, S>

where Q: RawState + Default + Eq + Hash, S: Eq + Hash,

fn from_iter<I>(iter: I) -> Self

where I: IntoIterator<Item = Rule<Q, S>>,

Creates a value from an iterator.

impl<Q, S> Index<Head<Q, S>> for RuleMap<Q, S>

where Q: RawState + Eq + Hash, S: Eq + Hash,

type Output = Tail<Q, S>

The returned type after indexing.

fn index(&self, head: Head<Q, S>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a, Q, S> IntoIterator for &'a RuleMap<Q, S>

where Q: RawState + Eq + Hash, S: Eq + Hash,

type Item = (&'a Head<Q, S>, &'a Tail<Q, S>)

The type of the elements being iterated over.

type IntoIter = Iter<'a, Head<Q, S>, Tail<Q, S>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, Q, S> IntoIterator for &'a mut RuleMap<Q, S>

where Q: RawState + Eq + Hash, S: Eq + Hash,

type Item = (&'a Head<Q, S>, &'a mut Tail<Q, S>)

The type of the elements being iterated over.

type IntoIter = IterMut<'a, Head<Q, S>, Tail<Q, S>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<Q, S> IntoIterator for RuleMap<Q, S>

where Q: RawState + Eq + Hash, S: Eq + Hash,

type Item = (Head<Q, S>, Tail<Q, S>)

The type of the elements being iterated over.

type IntoIter = IntoIter<Head<Q, S>, Tail<Q, S>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<Q, S> Serialize for RuleMap<Q, S>

where Q: RawState + Eq + Hash + Serialize, S: Eq + Hash + Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.