Struct ddo::core::utils::Func

pub struct Func<F>(pub F);

A zero-cost abstraction adapter for function pointers. This is typically useful to pass a pointer to function/closure as an heuristic to use in the solver/mdd configuration.

Note that, it implements different heuristics trait depending on the signature of the wrapped function F.

Trait Implementations

impl<F: Clone> Clone for Func<F>

fn clone(&self) -> Func<F>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, F> Compare<Node<T>, Node<T>> for Func<F> where
    F: Clone + Fn(&Node<T>, &Node<T>) -> Ordering, 

If the function is a node comparator, then Func will auto implement the Compare trait for that function.

fn compare(&self, a: &Node<T>, b: &Node<T>) -> Ordering

Compares two values, returning Less, Equal, or Greater if l is less than, equal to, or greater than r, respectively.

fn compares_lt(&self, l: &L, r: &R) -> bool

Checks if l is less than r.

fn compares_le(&self, l: &L, r: &R) -> bool

Checks if l is less than or equal to r.

fn compares_ge(&self, l: &L, r: &R) -> bool

Checks if l is greater than or equal to r.

fn compares_gt(&self, l: &L, r: &R) -> bool

Checks if l is greater than r.

fn compares_eq(&self, l: &L, r: &R) -> bool

Checks if l is equal to r.

fn compares_ne(&self, l: &L, r: &R) -> bool

Checks if l is not equal to r.

fn borrowing(self) -> Borrowing<Self, L, R>

Borrows the comparator's parameters before comparing them.

fn rev(self) -> Rev<Self>

Reverses the ordering of the comparator.

fn swap(self) -> Swap<Self>

Swaps the comparator's parameters, maintaining the underlying ordering.

fn then<D>(self, then: D) -> Then<Self, D> where
    D: Compare<L, R>, 

Lexicographically combines the comparator with another.

impl<T, F> LoadVars<T> for Func<F> where
    F: Fn(&Node<T>) -> VarSet, 

If is able to extract a set of variables out of a reference to some node, then Func will auto implement the LoadVars trait for that function.

fn variables(&self, node: &Node<T>) -> VarSet

Returns the minimal set of free variables for the given problem when starting an exploration in the given node.

impl<T, F> VariableHeuristic<T> for Func<F> where
    F: Fn(&VarSet, Layer<T>, Layer<T>) -> Option<Variable>, 

Whenever the parameter function of Func is a function/closure that possibly returns a variable based on a set of free variables and two layers (current and next), then Func will auto implement the VariableHeuristic trait for that function.

fn next_var(
    &self,
    free_vars: &VarSet,
    current: Layer<T>,
    next: Layer<T>
) -> Option<Variable>

Returns the best variable to branch on from the set of free_vars or None in case no branching is useful (free_vars is empty, no decision left to make, etc...).

impl<F> WidthHeuristic for Func<F> where
    F: Fn(&VarSet) -> usize, 

If the function determines a maximum width given a set of free vars, then Func will auto implement WidthHeuristic for that function.

fn max_width(&self, free_vars: &VarSet) -> usize

Returns the maximum width allowed for a layer.