Struct nonogrid::board::Board

pub struct Board<B> where
    B: Block,  { /* fields omitted */ }

Methods

impl<B> Board<B> where
    B: Block,
    B::Color: Copy, 

pub fn with_descriptions(
    rows: Vec<Description<B>>,
    columns: Vec<Description<B>>
) -> Self

pub fn with_descriptions_and_palette(
    rows: Vec<Description<B>>,
    columns: Vec<Description<B>>,
    palette: Option<ColorPalette>
) -> Self

pub fn desc_by_id(&self, id: ColorId) -> Option<ColorDesc>

pub fn iter_rows(&self) -> impl Iterator<Item = &[B::Color]>

pub fn descriptions(&self, rows: bool) -> &[ReadRc<Description<B>>]

pub fn height(&self) -> usize

pub fn width(&self) -> usize

pub fn is_solved_full(&self) -> bool

pub fn get_row(&self, index: usize) -> Vec<B::Color>

pub fn get_column(&self, index: usize) -> Vec<B::Color>

pub fn line_solution_rate<'a>(
    &self,
    line: impl Iterator<Item = &'a B::Color>,
    size: usize
) -> f64 where
    B::Color: 'a, 

How many cells in a line are known to be of particular color

pub fn row_solution_rate(&self, index: usize) -> f64

How many cells in the row with given index are known to be of particular color

pub fn column_solution_rate(&self, index: usize) -> f64

How many cells in the column with given index are known to be of particular color

pub fn solution_rate(&self) -> f64

How many cells in the whole grid are known to be of particular color

pub fn unsolved_cells(&self) -> impl Iterator<Item = Point> + '_

pub fn cell(&self, point: &Point) -> B::Color

pub fn unsolved_neighbours(
    &self,
    point: &Point
) -> impl Iterator<Item = Point> + '_

For the given cell yield the neighbour cells that are not completely solved yet.

pub fn init_cache(&mut self)

pub fn cached_solution(
    &mut self,
    is_column: bool,
    key: &CacheKey<B>
) -> Option<CacheValue<B>>

pub fn set_cached_solution(
    &mut self,
    is_column: bool,
    key: CacheKey<B>,
    solved: CacheValue<B>
)

pub fn print_cache_info(&self)

pub fn row_cache_index(&self, row_index: usize) -> usize

pub fn column_cache_index(&self, column_index: usize) -> usize

impl<B> Board<B> where
    B: Block, 

pub fn diff(&self, other: &[B::Color]) -> (Vec<Point>, Vec<Point>)

Difference between two boards as coordinates of changed cells. Standard diff semantic as result:

• first returned points which set in current board and unset in the other
• second returned points which unset in current board and set in the other

pub fn make_snapshot(&self) -> Vec<B::Color>

impl<B> Board<B> where
    B: Block, 

pub fn set_callback_on_set_line<CB: 'static + Fn(bool, usize) + Send + Sync>(
    &mut self,
    f: CB
)

pub fn set_callback_on_restore<CB: 'static + Fn() + Send + Sync>(
    &mut self,
    f: CB
)

pub fn set_callback_on_change_color<CB: 'static + Fn(Point) + Send + Sync>(
    &mut self,
    f: CB
)

pub fn set_row_with_callback(
    board_ref: MutRc<Self>,
    index: usize,
    new: &[B::Color]
)

pub fn set_column_with_callback(
    board_ref: MutRc<Self>,
    index: usize,
    new: &[B::Color]
)

pub fn restore_with_callback(board_ref: MutRc<Self>, cells: Vec<B::Color>)

pub fn set_color_with_callback(
    board_ref: MutRc<Self>,
    point: &Point,
    color: &B::Color
)

pub fn unset_color_with_callback(
    board_ref: MutRc<Self>,
    point: &Point,
    color: &B::Color
) -> Result<(), String>

Trait Implementations

impl<B> Clone for Board<B> where
    B: Block, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.