Struct monument::graph::Graph

pub struct Graph { /* private fields */ }

A ‘prototype’ chunk graph that is (relatively) inefficient to traverse but easy to modify. This is usually used to build and optimise the chunk graph before being converted into an efficient graph representation for use in tree search.

Implementations

impl Graph

Optimisation

pub fn optimise(&mut self, passes: &[Mutex<Pass>], query: &Query)

Repeatedly apply a sequence of Passes until the graph stops getting smaller, or 20 iterations are made. Use Graph::optimise_with_iter_limit to set a custom iteration limit.

pub fn optimise_with_iter_limit(
    &mut self,
    passes: &[Mutex<Pass>],
    query: &Query,
    limit: usize
)

Repeatedly apply a sequence of Passes until the graph either becomes static, or limit many iterations are performed.

pub fn split_by_start_chunk(&self) -> Vec<Graph>

For each start chunk in self, creates a copy of self with only that start chunk. This partitions the set of generated compositions across these Graphs, but allows for better optimisations because more is known about each Graph.

pub fn num_parts(&self) -> Rotation

pub fn size(&self) -> (usize, usize, Reverse<usize>)

Return a value representing the ‘size’ of this graph. Optimisation passes are required to never increase this quantity. Graph size is compared on the following factors (in order of precedence, most important first):

1. Number of nodes (smaller is better)
2. Number of links (smaller is better)
3. Number of required nodes (more is better)

impl Graph

Helpers for optimisation passes

pub fn retain_chunks(&mut self, pred: impl FnMut(&ChunkId, &mut Chunk) -> bool)

Removes all chunks for whom pred returns false

pub fn retain_links(
    &mut self,
    pred: impl FnMut(&Link, &ChunkId, &Chunk, &ChunkId, &Chunk) -> bool
)

Removes all links for whom pred returns false. The parameters of pred are (link, chunk_from, chunk_to)

pub fn retain_start_chunks(
    &mut self,
    pred: impl FnMut(&(ChunkId, StartIdx, Rotation)) -> bool
)

Remove elements from Self::start_chunks for which a predicate returns false.

pub fn retain_end_chunks(&mut self, pred: impl FnMut(&(ChunkId, End)) -> bool)

Remove elements from Self::end_chunks for which a predicate returns false.

impl Graph

Getters & Iterators

pub fn get_link(&self, id: LinkId) -> Option<&Link>

pub fn get_link_mut(&mut self, id: LinkId) -> Option<&mut Link>

pub fn get_chunk<'graph>(&'graph self, id: &ChunkId) -> Option<&'graph Chunk>

pub fn get_chunk_mut<'graph>(
    &'graph mut self,
    id: &ChunkId
) -> Option<&'graph mut Chunk>

pub fn start_chunks(&self) -> &[(ChunkId, StartIdx, Rotation)]

pub fn end_chunks(&self) -> &[(ChunkId, End)]

pub fn chunk_map(&self) -> &HashMap<ChunkId, Chunk>

pub fn get_start(&self, idx: usize) -> Option<(&Chunk, StartIdx, Rotation)>

pub fn ids(&self) -> impl Iterator<Item = &ChunkId>

An Iterator over the ChunkId of every Chunk in this Graph

pub fn chunks(&self) -> impl Iterator<Item = (&ChunkId, &Chunk)>

An Iterator over every Chunk in this Graph (including its ChunkId)

pub fn just_chunks(&self) -> impl Iterator<Item = &Chunk>

An Iterator over every Chunk in this Graph, without its ChunkId.

pub fn chunks_mut(&mut self) -> impl Iterator<Item = (&ChunkId, &mut Chunk)>

A mutable Iterator over the ChunkId of every Chunk in this Graph

impl Graph

pub fn new_unoptimised(
    query: &Query,
    config: &Config
) -> Result<Self, BuildError>

Generate a graph of all chunks which are reachable within a given length constraint.

Trait Implementations

impl Clone for Graph

fn clone(&self) -> Graph

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Graph

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

Formats the value using the given formatter.