Struct simplicity::dag::SwapChildren

pub struct SwapChildren<D>(/* private fields */);

A wrapper around a DAG-like reference that swaps the two children

This can be useful to modify the PostOrderIter behaviour to yield right children before left children.

Since it works by relabelling the children, when iterating with this adaptor, the “left” and “right” child indices will be inconsistent with the returned nodes. To correct this, you need to call PostOrderIterItem::unswap.

To avoid confusion, this structure cannot be directly costructed. Instead it is implicit in the DagLike::rtl_post_order_iter method.

Trait Implementations

impl<D: DagLike> DagLike for SwapChildren<D>

type Node = <D as DagLike>::Node

The type of the DAG node, with no references or wrappers

fn data(&self) -> &Self::Node

A pointer to the underlying data

fn as_dag_node(&self) -> Dag<Self>

Interpret the node as a DAG node

fn left_child(&self) -> Option<Self>

Accessor for the left child of the node, if one exists

fn right_child(&self) -> Option<Self>

Accessor for the right child of the node, if one exists

fn n_children(&self) -> usize

Number of children that the node has.

fn rtl_post_order_iter<S: SharingTracker<SwapChildren<Self>> + Default>( self ) -> RtlPostOrderIter<Self, S>

Obtains an iterator of all the nodes rooted at the DAG, in right-to-left post order.

fn pre_order_iter<S: SharingTracker<Self> + Default>( self ) -> PreOrderIter<Self, S>

Obtains an iterator of all the nodes rooted at the DAG, in pre-order.

fn post_order_iter<S: SharingTracker<Self> + Default>( self ) -> PostOrderIter<Self, S>

Obtains an iterator of all the nodes rooted at the DAG, in post order.

fn post_order_iter_with_tracker<S: SharingTracker<Self>>( self, tracker: S ) -> PostOrderIter<Self, S>

Obtains an post-order iterator of all the nodes rooted at DAG, using the given tracker.

impl<N, D> SharingTracker<SwapChildren<D>> for MaxSharing<N>

where D: DagLike, MaxSharing<N>: SharingTracker<D>, N: Marker,

fn record(&mut self, d: &SwapChildren<D>, index: usize) -> Option<usize>

Marks an object as having been seen, and record the index when it was seen.

fn seen_before(&self, d: &SwapChildren<D>) -> Option<usize>

Check whether an object has been seen before; if so, return the index it was recorded at.