klotski 0.0.2

Klotski multifunctional engine with high performance
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178

#[cxx::bridge(namespace = "klotski::ffi")]
mod ffi {
    #[derive(Debug)]
    struct RsLayout {
        code: u64
    }

    #[derive(Debug)]
    struct RsShortCode {
        code: u32
    }

    unsafe extern "C++" {
        include!("rust_ffi/include/layout.h");

        /// only for internal use
        fn layout_check(val: u64) -> bool;

        /// only for internal use
        fn layout_from_str(s: &str) -> u64;

        /// Convert Layout to string form.
        fn to_string(self: &RsLayout) -> String;

        /// Convert Layout to shorten string form.
        fn to_shorten_string(self: &RsLayout) -> String;

        /// Convert Layout to ShortCode.
        fn to_short_code(self: &RsLayout) -> RsShortCode;

        /// Whether the layout is vertically symmetrical.
        fn is_vertical_mirror(self: &RsLayout) -> bool;

        /// Whether the layout is horizontally symmetrical.
        fn is_horizontal_mirror(self: &RsLayout) -> bool;

        /// Calculate the vertically symmetrical klotski layout.
        fn to_vertical_mirror(self: &RsLayout) -> RsLayout;

        /// Calculate the horizontally symmetrical klotski layout.
        fn to_horizontal_mirror(self: &RsLayout) -> RsLayout;

        /// Obtain number of block 1x1.
        fn n_1x1(self: &RsLayout) -> u8;

        /// Obtain number of block 1x2.
        fn n_1x2(self: &RsLayout) -> u8;

        /// Obtain number of block 2x1.
        fn n_2x1(self: &RsLayout) -> u8;

        /// Obtain number of block 2x2.
        fn n_2x2(self: &RsLayout) -> u8;

        /// Obtain type_id value of current Layout.
        fn type_id(self: &RsLayout) -> u8;

        /// Obtain pattern_id value of current Layout.
        fn pattern_id(self: &RsLayout) -> u16;

        // TODO: add Toward enum for `toward` interface

        // Obtain toward char of current Layout.
        fn toward_char(self: &RsLayout) -> u8;

        /// Obtain case_id value of current Layout.
        fn case_id(self: &RsLayout) -> u32;

        /// Obtain all next cases in Layout.
        fn next_cases(self: &RsLayout) -> Vec<RsLayout>;
    }

    unsafe extern "C++" {
        include!("rust_ffi/include/short_code.h");

        /// only for internal use
        fn short_code_check(val: u32) -> bool;

        /// only for internal use
        fn short_code_from_str(s: &str) -> u32;

        /// Convert ShortCode to string form.
        fn to_string(self: &RsShortCode) -> String;

        /// Convert ShortCode to Layout.
        fn to_layout(self: &RsShortCode) -> RsLayout;

        /// Build the conversion index for ShortCode.
        fn short_code_speed_up(fast_mode: bool);
    }
}

pub use ffi::RsLayout as Layout;
pub use ffi::RsShortCode as ShortCode;

impl Layout {
    /// Check the validity of the original Layout.
    pub fn check(code: u64) -> bool {
        ffi::layout_check(code)
    }

    /// Create Layout without any check.
    pub fn unsafe_create(code: u64) -> Self {
        Self { code }
    }

    /// Create Layout with validity check.
    pub fn create(code: u64) -> Option<Self> {
        if Self::check(code) {
            return Some(Self::unsafe_create(code));
        }
        None
    }

    /// Get the original u64 code.
    pub fn unwrap(self: &Self) -> u64 {
        self.code
    }

    /// Create Layout from string form.
    pub fn from_string(s: &str) -> Option<Self> {
        let val = ffi::layout_from_str(s);
        if val < 0x10_FFFF_FFFF {
            return Some(Self::unsafe_create(val));
        }
        None
    }
}

impl ShortCode {
    /// Check the validity of the original ShortCode.
    pub fn check(code: u32) -> bool {
        ffi::short_code_check(code)
    }

    /// Create ShortCode without any check.
    pub fn unsafe_create(code: u32) -> Self {
        Self { code }
    }

    /// Create ShortCode with validity check.
    pub fn create(code: u32) -> Option<Self> {
        if Self::check(code) {
            return Some(Self::unsafe_create(code));
        }
        None
    }

    /// Get the original u32 code.
    pub fn unwrap(self: &Self) -> u32 {
        self.code
    }

    /// Create ShortCode from string form.
    pub fn from_string(s: &str) -> Option<Self> {
        let val = ffi::short_code_from_str(s);
        if val != 0xFFFF_FFFF {
            return Some(Self::unsafe_create(val));
        }
        None
    }

    pub fn speed_up(fast_mode: bool) {
        ffi::short_code_speed_up(fast_mode)
    }
}

impl PartialEq for Layout {
    fn eq(&self, other: &Self) -> bool {
        self.code == other.code
    }
}

impl PartialEq for ShortCode {
    fn eq(&self, other: &Self) -> bool {
        self.code == other.code
    }
}