twips 0.12.2

Twizzle Pattern Searcher — Twisty puzzle search library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

use derive_more::From;

use std::path::PathBuf;

use crate::_internal::{errors::ArgumentError, read_to_json::read_to_json};
use cubing::{
    alg::Alg,
    kpuzzle::{KPattern, KPatternData, KPuzzle, KPuzzleDefinition},
};

// TODO: can we afford to make these fields into references?
#[derive(Debug, From)]
pub enum KPuzzleSource {
    KPuzzle(KPuzzle),
    KPuzzleDefinition(KPuzzleDefinition),
    FilePath(PathBuf),
}

impl KPuzzleSource {
    pub fn kpuzzle(self) -> Result<KPuzzle, ArgumentError /* TODO */> {
        let def = match self {
            KPuzzleSource::KPuzzle(kpuzzle) => return Ok(kpuzzle),
            KPuzzleSource::KPuzzleDefinition(kpuzzle_definition) => kpuzzle_definition,
            KPuzzleSource::FilePath(path_buf) => read_to_json(&path_buf)?,
        };

        KPuzzle::try_from(def).map_err(|e| ArgumentError {
            description: format!("Invalid definition: {}", e),
        })
    }
}

// TODO: can we afford to make these fields into references?
#[derive(Debug, From, Default)]
pub enum PatternSource {
    #[default]
    DefaultFromDefinition,
    FilePath(PathBuf),
    AlgAppliedToDefaultPattern(Alg),
}

impl PatternSource {
    pub fn kpattern(
        &self,
        kpuzzle: &KPuzzle,
    ) -> Result<Option<KPattern>, ArgumentError /* TODO */> {
        Ok(match self {
            PatternSource::DefaultFromDefinition => None,
            PatternSource::FilePath(path_buf) => {
                let kpattern_data: KPatternData = read_to_json(path_buf)?;
                match KPattern::try_from_data(kpuzzle, &kpattern_data) {
                    Ok(start_or_target_pattern) => Some(start_or_target_pattern),
                    Err(e) => {
                        return Err(ArgumentError {
                            description: e.to_string(),
                        })
                    }
                }
            }
            PatternSource::AlgAppliedToDefaultPattern(alg) => {
                match kpuzzle.default_pattern().apply_alg(alg) {
                    Ok(pattern) => Some(pattern),
                    Err(err) => {
                        return Err(ArgumentError {
                            description: err.to_string(), // TODO
                        });
                    }
                }
            }
        })
    }
}