Struct Manager 

pub struct Manager<'id, N, ET, TM, R, MD, const TERMINALS: usize>
where
    N: NodeBase + InnerNode<Edge<'id, N, ET>>,
    ET: Tag,
    TM: TerminalManager<'id, N, ET, TERMINALS>,
    MD: DropWith<Edge<'id, N, ET>>,
{ /* private fields */ }

Trait Implementations

impl<'id, T, N, ET, TM, R, MD, const TERMINALS: usize> AsMut<T> for Manager<'id, N, ET, TM, R, MD, TERMINALS>

where N: NodeBase + InnerNode<Edge<'id, N, ET>>, ET: Tag, TM: TerminalManager<'id, N, ET, TERMINALS>, MD: DropWith<Edge<'id, N, ET>> + AsMut<T>,

fn as_mut(&mut self) -> &mut T

Converts this type into a mutable reference of the (usually inferred) input type.

impl<'id, T, N, ET, TM, R, MD, const TERMINALS: usize> AsRef<T> for Manager<'id, N, ET, TM, R, MD, TERMINALS>

where N: NodeBase + InnerNode<Edge<'id, N, ET>>, ET: Tag, TM: TerminalManager<'id, N, ET, TERMINALS>, MD: DropWith<Edge<'id, N, ET>> + AsRef<T>,

fn as_ref(&self) -> &T

Converts this type into a shared reference of the (usually inferred) input type.

impl<'a, 'id, NC: InnerNodeCons<ET>, ET: Tag, TMC: TerminalManagerCons<NC, ET, TERMINALS>, RC: DiagramRulesCons<NC, ET, TMC, MDC, TERMINALS>, MDC: ManagerDataCons<NC, ET, TMC, RC, TERMINALS>, const TERMINALS: usize> From<&'a Manager<'id, <NC as InnerNodeCons<ET>>::T<'id>, ET, <TMC as TerminalManagerCons<NC, ET, TERMINALS>>::T<'id>, <RC as DiagramRulesCons<NC, ET, TMC, MDC, TERMINALS>>::T<'id>, <MDC as ManagerDataCons<NC, ET, TMC, RC, TERMINALS>>::T<'id>, TERMINALS>> for ManagerRef<NC, ET, TMC, RC, MDC, TERMINALS>

fn from( manager: &'a Manager<'id, <NC as InnerNodeCons<ET>>::T<'id>, ET, <TMC as TerminalManagerCons<NC, ET, TERMINALS>>::T<'id>, <RC as DiagramRulesCons<NC, ET, TMC, MDC, TERMINALS>>::T<'id>, <MDC as ManagerDataCons<NC, ET, TMC, RC, TERMINALS>>::T<'id>, TERMINALS>, ) -> Self

Converts to this type from the input type.

impl<'id, N: NodeBase + InnerNode<Edge<'id, N, ET>>, ET: Tag, TM: TerminalManager<'id, N, ET, TERMINALS>, R: DiagramRules<Edge<'id, N, ET>, N, TM::TerminalNode>, MD: HasApplyCache<Self, O> + ManagerEventSubscriber<Self> + DropWith<Edge<'id, N, ET>>, O: Copy, const TERMINALS: usize> HasApplyCache<Manager<'id, N, ET, TM, R, MD, TERMINALS>, O> for Manager<'id, N, ET, TM, R, MD, TERMINALS>

type ApplyCache = <MD as HasApplyCache<Manager<'id, N, ET, TM, R, MD, TERMINALS>, O>>::ApplyCache

The concrete apply cache type

fn apply_cache(&self) -> &Self::ApplyCache

Get a shared reference to the contained apply cache

fn apply_cache_mut(&mut self) -> &mut Self::ApplyCache

Get a mutable reference to the contained apply cache

impl<'id, N, ET, TM, R, MD, const TERMINALS: usize> HasWorkers for Manager<'id, N, ET, TM, R, MD, TERMINALS>

where N: NodeBase + InnerNode<Edge<'id, N, ET>> + Send + Sync, ET: Tag + Send + Sync, TM: TerminalManager<'id, N, ET, TERMINALS> + Send + Sync, R: DiagramRules<Edge<'id, N, ET>, N, TM::TerminalNode>, MD: DropWith<Edge<'id, N, ET>> + ManagerEventSubscriber<Self> + Send + Sync,

type WorkerPool = Workers

Type of the worker pool

fn workers(&self) -> &Self::WorkerPool

Get the worker pool

impl<'id, N, ET, TM, R, MD, const TERMINALS: usize> Manager for Manager<'id, N, ET, TM, R, MD, TERMINALS>

where N: NodeBase + InnerNode<Edge<'id, N, ET>>, ET: Tag, TM: TerminalManager<'id, N, ET, TERMINALS>, R: DiagramRules<Edge<'id, N, ET>, N, TM::TerminalNode>, MD: DropWith<Edge<'id, N, ET>> + ManagerEventSubscriber<Self>,

type Edge = Edge<'id, N, ET>

Type of edge

type EdgeTag = ET

Type of edge tags

type InnerNode = N

Type of inner nodes

type Terminal = <TM as TerminalManager<'id, N, ET, TERMINALS>>::TerminalNode

Type of terminals

type TerminalRef<'a> = <TM as TerminalManager<'id, N, ET, TERMINALS>>::TerminalNodeRef<'a> where Self: 'a

References to Self::Terminals

type Rules = R

Diagram rules, see DiagramRules for more details

type TerminalIterator<'a> = <TM as TerminalManager<'id, N, ET, TERMINALS>>::Iterator<'a> where Self: 'a

Iterator over all terminals

type NodeSet = NodeSet

Node set type, possibly more efficient than a HashSet<NodeID>

type LevelView<'a> = LevelView<'a, 'id, N, ET, TM, R, MD, TERMINALS> where Self: 'a

A view on a single level of the unique table.

type LevelIterator<'a> = LevelIter<'a, 'id, N, ET, TM, R, MD, TERMINALS> where Self: 'a

Iterator over levels

fn get_node(&self, edge: &Self::Edge) -> Node<'_, Self>

Get a reference to the node to which edge points

fn clone_edge(&self, edge: &Self::Edge) -> Self::Edge

Clone edge

fn drop_edge(&self, edge: Self::Edge)

Drop edge

fn try_remove_node(&self, edge: Edge<'id, N, ET>, level: LevelNo) -> bool

Drop edge and try to remove the node it points to

fn num_inner_nodes(&self) -> usize

Get the count of inner nodes

fn approx_num_inner_nodes(&self) -> usize

Get an approximate count of inner nodes

fn num_levels(&self) -> LevelNo

Get the number of levels

fn num_named_vars(&self) -> VarNo

Get the number of named variables

fn add_vars(&mut self, additional: VarNo) -> Range<VarNo>

Add additional unnamed variables to the decision diagram

fn add_named_vars<S: Into<String>>( &mut self, names: impl IntoIterator<Item = S>, ) -> Result<Range<VarNo>, DuplicateVarName>

Add named variables to the decision diagram

fn add_named_vars_from_map( &mut self, map: VarNameMap, ) -> Result<Range<VarNo>, DuplicateVarName>

Add named variables to the decision diagram

fn var_name(&self, var: VarNo) -> &str

Get var’s name

fn set_var_name( &mut self, var: VarNo, name: impl Into<String>, ) -> Result<(), DuplicateVarName>

Label var as name

fn name_to_var(&self, name: impl AsRef<str>) -> Option<VarNo>

Get the variable number for the given variable name, if present

fn var_to_level(&self, var: VarNo) -> LevelNo

Get the level for the given variable

fn level_to_var(&self, level: LevelNo) -> VarNo

Get the variable for the given level

fn level(&self, no: LevelNo) -> Self::LevelView<'_>

Get the level given by no

fn levels(&self) -> Self::LevelIterator<'_>

Iterate over the levels from top to bottom

fn get_terminal(&self, terminal: Self::Terminal) -> AllocResult<Self::Edge>

Get an edge for the given terminal

fn num_terminals(&self) -> usize

Get the number of terminals

fn terminals(&self) -> Self::TerminalIterator<'_>

Iterator over all terminals

fn gc(&self) -> usize

Perform garbage collection

fn reorder<T>(&mut self, f: impl FnOnce(&mut Self) -> T) -> T

Prepare and postprocess a reordering operation. The reordering itself is performed in f.

fn gc_count(&self) -> u64

Get the count of garbage collections

fn reorder_count(&self) -> u64

Get the count of reordering operations

fn num_vars(&self) -> u32

Get the number of variables

impl<'id, N: NodeBase + InnerNode<Edge<'id, N, ET>> + Send + Sync, ET: Tag + Send + Sync, TM: TerminalManager<'id, N, ET, TERMINALS> + Send + Sync, R, MD: DropWith<Edge<'id, N, ET>> + Send + Sync, const TERMINALS: usize> Send for Manager<'id, N, ET, TM, R, MD, TERMINALS>

impl<'id, N: NodeBase + InnerNode<Edge<'id, N, ET>> + Send + Sync, ET: Tag + Send + Sync, TM: TerminalManager<'id, N, ET, TERMINALS> + Send + Sync, R, MD: DropWith<Edge<'id, N, ET>> + Send + Sync, const TERMINALS: usize> Sync for Manager<'id, N, ET, TM, R, MD, TERMINALS>