Struct gpp_solver::Solver

pub struct Solver<P> { /* fields omitted */ }

Hybrid push-pull solver.

Implementations

impl<P> Solver<P>

pub fn new(problem_instance: P) -> Self

Create a new Solver instance for a Problem instance.

pub fn into_problem_instance(self) -> P

Consume self and return the wrapped Problem instance.

pub async fn status(&self) -> Status

Get the current Status of the solver.

pub async fn enqueue_fragment(&self, id: FragmentId) -> &Self

Enqueue a fragment to be solved.

Only fragments enqueued through this method and their transitive dependencies will be considered for evaluation.

pub async fn punted_iter(&self) -> Vec<FragmentId>

Get an interator to all fragments that are currently punted. Interpretation of punted fragments depends on the current status:

• Status::Pending: fragments are pending on dependencies.
• Status::DoneWithCycles: fragments are part of one or more cycles.
• Status::Done: the returned iterator will be empty.

impl<P> Solver<P> where
    P: Problem, 

pub async fn assume_evaluated(&self, id: FragmentId) -> &Self

Assume the given fragment is already evaluated.

pub async fn run(
    &self,
    concurrency: NonZeroUsize
) -> Result<Vec<FragmentId>, P::Error>

Run the solver until all enqueued fragments and their transitive dependencies are either solved or proven to be part of cycles. See the module docs for the limitations when concurrency > 1.

Returns an interator with all fragments that are part of at least one cycle, if any. See Solver::punted_iter.

Returns an error if any evaluation returns an error.

Known Issues

• If Solver::enqueue_fragment is called while Solver::run is executing, those new fragments may not be solved.
• If Solver::run returns with an error, the Solver may be left in an inconsistent state.

pub async fn step(&self) -> Result<bool, P::Error>

Run a single solver step for a single fragment.

Returns false if there are no more fragments that can be evaluated.

Returns an error if Problem::evaluate was called and evaluation returned an error.

Known Issues

• If Solver::step is not run to completion the Solver may be left in an inconsistent state.