Struct esl01_dag::namedag::NameDag

pub struct NameDag { /* fields omitted */ }

A DAG that uses VertexName instead of ids as vertexes.

A high-level wrapper structure. Combination of IdMap and [Dag]. Maintains consistency of dag and map internally.

Methods

impl NameDag

pub fn open(path: impl AsRef<Path>) -> Result<Self>

pub fn add_heads_and_flush<F>(
    &mut self,
    parent_names_func: F,
    master_names: &[VertexName],
    non_master_names: &[VertexName]
) -> Result<()> where
    F: Fn(VertexName) -> Result<Vec<VertexName>>, 

Add vertexes and their ancestors to the on-disk DAG.

This is similar to calling add_heads followed by flush. But is faster.

pub fn add_heads<F>(&mut self, parents: F, heads: &[VertexName]) -> Result<()> where
    F: Fn(VertexName) -> Result<Vec<VertexName>>, 

Add vertexes and their ancestors to the in-memory DAG.

This does not write to disk. Use add_heads_and_flush to add heads and write to disk more efficiently.

The added vertexes are immediately query-able. They will get Ids assigned to the NON_MASTER group internally. The flush function can re-assign Ids to the MASTER group.

pub fn flush(&mut self, master_heads: &[VertexName]) -> Result<()>

Write in-memory DAG to disk. This will also pick up changes to the DAG by other processes.

pub fn reload(&mut self) -> Result<()>

Reload segments from disk. This discards in-memory content.

pub fn sort(&self, set: &NameSet) -> Result<NameSet>

Sort a NameSet topologically.

pub fn parent_names(&self, name: VertexName) -> Result<Vec<VertexName>>

Get ordered parent vertexes.

impl NameDag

pub fn all(&self) -> Result<NameSet>

Returns a SpanSet that covers all vertexes tracked by this DAG.

pub fn ancestors(&self, set: NameSet) -> Result<NameSet>

Calculates all ancestors reachable from any name from the given set.

pub fn parents(&self, set: NameSet) -> Result<NameSet>

Calculates parents of the given set.

Note: Parent order is not preserved. Use NameDag::parent_names to preserve order.

pub fn first_ancestor_nth(&self, name: VertexName, n: u64) -> Result<VertexName>

Calculates the n-th first ancestor.

pub fn heads(&self, set: NameSet) -> Result<NameSet>

Calculates heads of the given set.

pub fn children(&self, set: NameSet) -> Result<NameSet>

Calculates children of the given set.

pub fn roots(&self, set: NameSet) -> Result<NameSet>

Calculates roots of the given set.

pub fn gca_one(&self, set: NameSet) -> Result<Option<VertexName>>

Calculates one "greatest common ancestor" of the given set.

If there are no common ancestors, return None. If there are multiple greatest common ancestors, pick one arbitrarily. Use gca_all to get all of them.

pub fn gca_all(&self, set: NameSet) -> Result<NameSet>

Calculates all "greatest common ancestor"s of the given set. gca_one is faster if an arbitrary answer is ok.

pub fn common_ancestors(&self, set: NameSet) -> Result<NameSet>

Calculates all common ancestors of the given set.

pub fn is_ancestor(
    &self,
    ancestor: VertexName,
    descendant: VertexName
) -> Result<bool>

Tests if ancestor is an ancestor of descendant.

pub fn heads_ancestors(&self, set: NameSet) -> Result<NameSet>

Calculates "heads" of the ancestors of the given set. That is, Find Y, which is the smallest subset of set X, where ancestors(Y) is ancestors(X).

This is faster than calculating heads(ancestors(set)).

This is different from heads. In case set contains X and Y, and Y is an ancestor of X, but not the immediate ancestor, heads will include Y while this function won't.

pub fn range(&self, roots: NameSet, heads: NameSet) -> Result<NameSet>

Calculates the "dag range" - vertexes reachable from both sides.

pub fn descendants(&self, set: NameSet) -> Result<NameSet>

Calculates the descendants of the given set.

Trait Implementations

impl LowLevelAccess for NameDag

fn dag(&self) -> &IdDag<IndexedLogStore>

fn map(&self) -> &IdMap