Struct sudoku_variants::constraint::CompositeConstraint

pub struct CompositeConstraint<C1, C2> where
    C1: Constraint + Clone + 'static,
    C2: Constraint + Clone + 'static,  { /* fields omitted */ }

A Constraint which simultaneously enforces two other constraints. This allows the construction of complex constraints by nesting composite constraints.

As an example, a constraint with DefaultConstraint, DiagonalsConstraint, and KnightsMoveConstraint would be constructed as follows:

use sudoku_variants::constraint::{
    CompositeConstraint,
    DefaultConstraint,
    DiagonalsConstraint,
    KnightsMoveConstraint
};

let constraint = CompositeConstraint::new(
    DefaultConstraint,
    CompositeConstraint::new(
        DiagonalsConstraint,
        KnightsMoveConstraint
    )
);

The advantage of using this over a DynamicConstraint is that it is statically known which types of constraints are used, so no dynamic dispatch is necessary. On the contrary, a CompositeConstraint is less flexible.

Implementations

impl<C1, C2> CompositeConstraint<C1, C2> where
    C1: Constraint + Clone + 'static,
    C2: Constraint + Clone + 'static, 

pub fn new(c1: C1, c2: C2) -> CompositeConstraint<C1, C2>

Creates a new composite constraint from the two child consraints which will be enforced.

Trait Implementations

impl<C1: Clone, C2: Clone> Clone for CompositeConstraint<C1, C2> where
    C1: Constraint + Clone + 'static,
    C2: Constraint + Clone + 'static, 

fn clone(&self) -> CompositeConstraint<C1, C2>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<C1, C2> Constraint for CompositeConstraint<C1, C2> where
    C1: Constraint + Clone + 'static,
    C2: Constraint + Clone + 'static, 

fn check(&self, grid: &SudokuGrid) -> bool

Checks whether the given SudokuGrid matches this constraint, that is, every cell matches this constraint. By default, this runs check_cell on every cell of the grid, which may be inefficient, so custom implementations may be advantageous.

fn check_cell(&self, grid: &SudokuGrid, column: usize, row: usize) -> bool

Checks whether the cell at the given position in the SudokuGrid fulfills the constraint. This is the same as calling check_number with the same coordinates and the number which is actually filled in that cell. If the cell is empty, this function always returns true.

fn check_number(
    &self,
    grid: &SudokuGrid,
    column: usize,
    row: usize,
    number: usize
) -> bool

Checks whether the given number would fit into the cell specified by column and row into the grid without violating this constraint. This function does not have to check whether number is actually a valid number for this grid (i.e. in the interval [1, size]). If you require this guarantee, use Sudoku::is_valid_number instead.

fn get_groups(&self, grid: &SudokuGrid) -> Vec<Group>

Gets a vector of all groups that are defined by this constraint. A group is a set of cells which may not contain repeated numbers. As an example, the BlockConstraint defines each block as a group. Some constraints, such as the KingsMoveConstraint, do not have groups. In this particular case, a cell removed by a kings-move to the top-left may be the same as one to the bottom-right, so the cells removed by a kings-move from any particular cell cannot form a group. Such constraints should return an empty vector here.