pub(crate) mod ffi;
pub(crate) mod err;
use err::{CubeError, CubeStringError};
use ffi::CUBE_BS;
pub use ffi::CUBE_ID;
use std::ffi::{CStr, CString};
use std::fmt;
use std::ops::Deref;
use std::os::raw::c_char;
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Cube(CString);
impl Cube {
pub fn new(s: impl AsRef<str>) -> Result<Self, CubeStringError> {
let str_ref = s.as_ref();
if str_ref.len() != 54 {
return Err(CubeStringError::InvalidLength(str_ref.len()))
}
let c_str = CString::new(s.as_ref()).map_err(|_| CubeStringError::InteriorNulByte)?;
Ok(Cube(c_str))
}
pub(crate) fn as_ptr(&self) -> *const c_char {
self.0.as_ptr()
}
pub(crate) fn as_str(&self) -> &str {
self.0.to_str().expect("Cube string is valid UTF-8")
}
pub fn is_solvable(&self) -> bool {
unsafe { ffi::solvable(self.as_ptr()) }
}
pub fn apply_maneuver_mut(&mut self, maneuver: impl AsRef<str>) -> Result<(), CubeStringError>{
let c_maneuver = CString::new(maneuver.as_ref()).map_err(|_| CubeStringError::InteriorNulByte)?;
let mut buffer = [0u8; CUBE_BS];
let success = unsafe {
ffi::facecube(
buffer.as_mut_ptr() as *mut c_char,
c_maneuver.as_ptr(),
self.as_ptr()
)
};
if !success {
return Err(CubeStringError::InvalidManeuver);
}
let c_str = unsafe { CStr::from_ptr(buffer.as_ptr() as *const c_char) };
self.0 = c_str.to_owned();
Ok(())
}
pub fn apply_maneuver(&self, maneuver: impl AsRef<str>) -> Result<Cube, CubeStringError> {
let mut cloned = self.clone();
cloned.apply_maneuver_mut(maneuver)?;
Ok(cloned)
}
pub fn solve(&self) -> Result<String, CubeError> {
CubeSolver::new().src(self.clone()).solve()
}
}
impl Default for Cube {
fn default() -> Self {
Cube::new(CUBE_ID).unwrap()
}
}
impl Deref for Cube {
type Target = str;
fn deref(&self) -> &Self::Target {
self.as_str()
}
}
impl fmt::Display for Cube {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.as_str())
}
}
pub fn permutation(ms_or_cube: impl AsRef<str>, fmt: i32) -> String {
let Ok(ms_or_cube) = CString::new(ms_or_cube.as_ref()) else {
return "???".to_string();
};
let mut buffer = [0u8; CUBE_BS];
unsafe {
let success = ffi::permutation(
buffer.as_mut_ptr() as *mut c_char,
ms_or_cube.as_ptr(),
fmt
);
if !success {
return "???".to_string();
}
CStr::from_ptr(buffer.as_ptr() as *const c_char)
.to_string_lossy()
.into_owned()
}
}
#[derive(Debug, Clone)]
pub struct CubeSolver {
src: Option<Cube>,
tgt: Option<Cube>,
step: i32,
best: bool,
}
impl CubeSolver {
pub fn new() -> Self {
Self {
src: None,
tgt: None,
step: 30,
best: true,
}
}
pub fn src(mut self, src: Cube) -> Self {
self.src = Some(src);
self
}
pub fn tgt(mut self, tgt: Cube) -> Self {
self.tgt = Some(tgt);
self
}
pub fn max_steps(mut self, step: i32) -> Self {
self.step = step;
self
}
pub fn best(mut self, best: bool) -> Self {
self.best = best;
self
}
pub fn solve(self) -> Result<String, CubeError> {
let src_ptr = self.src.as_ref().map_or(std::ptr::null(), |s| s.as_ptr());
let tgt_ptr = self.tgt.as_ref().map_or(std::ptr::null(), |s| s.as_ptr());
let mut buffer = [0u8; CUBE_BS];
let res = unsafe {
ffi::solve(
buffer.as_mut_ptr() as *mut c_char,
src_ptr,
tgt_ptr,
self.step,
self.best,
)
};
if res == ffi::SolveResult::Success {
let c_str = unsafe { CStr::from_ptr(buffer.as_ptr() as *const c_char) };
Ok(c_str.to_string_lossy().into_owned())
} else {
Err(res.into())
}
}
}
impl Default for CubeSolver {
fn default() -> Self {
Self::new()
}
}