Struct sudoku_backend::ops::SudokuBoard

pub struct SudokuBoard {
    pub id: Option<i32>,
    pub full_board: String,
    pub difficulty: i32,
    pub creation_time: NaiveDateTime,
}

Refer to doc/sudoku.md for more details.

Fields

id: Option<i32>

Unique board ID.

Actually not optional, but this allows us to get an ID from the database.

full_board: String

The full "solved" board repr.

difficulty: i32

Board "difficulty", between one and three.

creation_time: NaiveDateTime

Time the board was generated.

Methods

impl SudokuBoard

pub fn new(difficulty: BoardDifficulty) -> SudokuBoard

Create a new, unique, sudoku board.

Put it in the database to get an ID.

pub fn get(id: i32, db: &SqliteConnection) -> Result<SudokuBoard, &'static str>

Retrieve the board with the specified ID.

Examples

Given:

INSERT INTO "sudoku_boards"
    VALUES(
        1,
        '269574813534918726781263594395846271478129365126357948857491632913682457642735189',
        3,
        '2018-08-01 23:50:14');

The following holds:

let board = SudokuBoard::get(1, &db).unwrap();
assert_eq!(board, SudokuBoard {
    id: Some(1),
    full_board: "269574813534918726781263594395846271478129365126357948857491632913682457642735189".to_string(),
    difficulty: 3,
    creation_time: NaiveDate::from_ymd(2018, 8, 1).and_hms(23, 50, 14),
});

pub fn insert(&mut self, db: &SqliteConnection) -> Result<(), &'static str>

Insert this board into the specified DB, updating its id.

Examples

Assuming empty table:

let mut board = SudokuBoard::new(difficulty);
assert!(board.id.is_none());

board.insert(&db).unwrap();
assert_eq!(board.id, Some(1));

After, example:

INSERT INTO "sudoku_boards"
    VALUES(
        1,
        '269574813534918726781263594395846271478129365126357948857491632913682457642735189',
        3,
        '2018-08-01 23:50:14');

pub fn generate_skeleton(&self) -> Result<String, SudokuLineFormatParseError>

Get а board skeleton adjusted for the difficulty.

Quoth the Raven Animu_x63:

The absolute measures of sudoku difficulty are the average sparsity of squares (over all gamestates) that can logically be resolved, and the maximum amount of logical deductions required to fill in the easiest square along states leading to the solution.

But that's hard. However:

Most other measurements of difficulty are just arbitrary and you can approximate difficult by sparsity.

And that is what we do here: get a unique solution, then partially fill it back in according to BoardDifficulty::additional_squares().

Examples

let easy_board = SudokuBoard::new(BoardDifficulty::Easy);
let easy_skeleton = easy_board.generate_skeleton().unwrap();

let medium_board = SudokuBoard::new(BoardDifficulty::Medium);
let medium_skeleton = medium_board.generate_skeleton().unwrap();

assert!(  easy_skeleton.chars().filter(|&c| c != '.').count() >
        medium_skeleton.chars().filter(|&c| c != '.').count());

let hard_board = SudokuBoard::new(BoardDifficulty::Hard);
let hard_skeleton = hard_board.generate_skeleton().unwrap();

assert!(medium_skeleton.chars().filter(|&c| c != '.').count() >
          hard_skeleton.chars().filter(|&c| c != '.').count());

Trait Implementations

impl PartialEq<SudokuBoard> for SudokuBoard

fn eq(&self, other: &SudokuBoard) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &SudokuBoard) -> bool

This method tests for !=.

impl Clone for SudokuBoard

fn clone(&self) -> SudokuBoard

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Ord for SudokuBoard

fn cmp(&self, other: &SudokuBoard) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

impl Eq for SudokuBoard

impl PartialOrd<SudokuBoard> for SudokuBoard

fn partial_cmp(&self, other: &SudokuBoard) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &SudokuBoard) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &SudokuBoard) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &SudokuBoard) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &SudokuBoard) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Debug for SudokuBoard

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

Formats the value using the given formatter.

impl Hash for SudokuBoard

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where     H: Hasher,

Feeds a slice of this type into the given [Hasher].

impl Serialize for SudokuBoard

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where     __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'de> Deserialize<'de> for SudokuBoard

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where     __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'insert> Insertable<table> for SudokuBoard

type Values = <(Option<Eq<id, i32>>, Option<Eq<full_board, String>>, Option<Eq<difficulty, i32>>, Option<Eq<creation_time, NaiveDateTime>>) as Insertable<table>>::Values

The VALUES clause to insert these records

fn values(self) -> Self::Values

Construct Self::Values

fn insert_into(     self,     table: T ) -> InsertStatement<T, Self::Values, Insert, NoReturningClause>

Insert self into a given table.

impl<'insert> Insertable<table> for &'insert SudokuBoard

type Values = <(Option<Eq<id, &'insert i32>>, Option<Eq<full_board, &'insert String>>, Option<Eq<difficulty, &'insert i32>>, Option<Eq<creation_time, &'insert NaiveDateTime>>) as Insertable<table>>::Values

The VALUES clause to insert these records

fn values(self) -> Self::Values

Construct Self::Values

fn insert_into(     self,     table: T ) -> InsertStatement<T, Self::Values, Insert, NoReturningClause>

Insert self into a given table.

impl<__DB: Backend, __ST> Queryable<__ST, __DB> for SudokuBoard where     (Option<i32>, String, i32, NaiveDateTime): Queryable<__ST, __DB>,

type Row = <(Option<i32>, String, i32, NaiveDateTime) as Queryable<__ST, __DB>>::Row

The Rust type you'd like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

impl<'update> AsChangeset for &'update SudokuBoard

type Target = table

The table which Self::Changeset will be updating

type Changeset = <(Eq<full_board, &'update String>, Eq<difficulty, &'update i32>, Eq<creation_time, &'update NaiveDateTime>) as AsChangeset>::Changeset

The update statement this type represents

fn as_changeset(self) -> Self::Changeset

Convert self into the actual update statement being executed

impl<'update> AsChangeset for SudokuBoard

type Target = table

The table which Self::Changeset will be updating

type Changeset = <(Eq<full_board, String>, Eq<difficulty, i32>, Eq<creation_time, NaiveDateTime>) as AsChangeset>::Changeset

The update statement this type represents

fn as_changeset(self) -> Self::Changeset

Convert self into the actual update statement being executed

impl<'insert> UndecoratedInsertRecord<table> for SudokuBoard