nissy-core

nissy.cpp (6816B)

---

 /*
 C++20 interface for nissy.
 
 TODO: add more documentation (here and in README.md)
 */
 
 #include "./nissy.h"
 
 #include <fstream>
 
 extern "C" {
 	long long nissy_inverse(const char *, char *);
 	long long nissy_applymoves(const char *, const char *, char *);
 	long long nissy_applytrans(const char *, const char *, char *);
 	long long nissy_variations(const char *, const char *,
 	    unsigned long long, char*);
 	long long nissy_getcube(long long, long long, long long, long long,
 	    long long, const char *, char *);
 	long long nissy_solverinfo(const char *, char *);
 	long long nissy_gendata(const char *, unsigned long long,
 	    unsigned char *);
 	long long nissy_checkdata(const char *, unsigned long long,
 	    const unsigned char *);
 	long long nissy_solve(const char *, const char *, unsigned, unsigned,
 	    unsigned, unsigned, unsigned, unsigned, unsigned long long,
 	    const unsigned char *, unsigned, char *, long long *,
 	    int (*)(void *), void *);
 	long long nissy_countmoves(const char *);
 	long long nissy_comparemoves(const char *, const char *);
 	long long nissy_setlogger(void (*)(const char *, void *), void *);
 }
 
 namespace nissy {
 
 	/* Definition of constants with const qualifier */
 	const nissflag nissflag::NORMAL{1};
 	const nissflag nissflag::INVERSE{2};
 	const nissflag nissflag::MIXED{4};
 	const nissflag nissflag::LINEAR{3};
 	const nissflag nissflag::ALL{7};
 
 	const error error::OK{0};
 	const error error::UNSOLVABLE_WARNING{-1};
 	const error error::UNSOLVABLE_ERROR{-11};
 	const error error::INVALID_CUBE{-10};
 	const error error::INVALID_MOVES{-20};
 	const error error::INVALID_TRANS{-30};
 	const error error::INVALID_SOLVER{-50};
 	const error error::INVALID_VARIATION{-51};
 	const error error::NULL_POINTER{-60};
 	const error error::BUFFER_SIZE{-61};
 	const error error::DATA{-70};
 	const error error::OPTIONS{-80};
 	const error error::UNKNOWN{-999};
 
 	const status status::RUN{0};
 	const status status::STOP{1};
 	const status status::PAUSE{2};
 
 	const compare_result compare_result::EQUAL{0};
 	const compare_result compare_result::DIFFERENT{99};
 
 	namespace size {
 		constexpr size_t CUBE = 24;
 		constexpr size_t TRANSFORMATION = 12;
 		constexpr size_t SOLVE_STATS = 10;
 		constexpr size_t DATAID = 255;
 		constexpr size_t MOVES = 1000;
 	}
 
 	bool error::ok() const { return value >= 0; }
 
 	variation::variation(const std::string& str) : name{str} {}
 
 	variation::variations_result
 	variation::find_variations(const std::string& moves)
 	{
 		variation::variations_result result;
 
 		const size_t len = 3 * size::MOVES * 16;
 		result.solutions.resize(len);
 
 		auto err = nissy_variations(moves.c_str(), name.c_str(), len,
 		    result.solutions.data());
 
 		int size = result.solutions.find_first_of('\0');
 		result.solutions.resize(size);
 		result.err = error{err};
 
 		return result;
 	}
 
 	std::variant<variation, error>
 	variation::get(const std::string& name) {
 		char result[10];
 		variation s(name);
 
 		if (nissy_variations("", name.c_str(), 10, result) < 0)
 			return error::INVALID_VARIATION;
 		else
 			return s;
 	}
 
 	cube::cube() {}
 
 	error cube::move(const std::string& moves)
 	{
 		char result[size::CUBE];
 		long long err = nissy_applymoves(
 		    m_str.c_str(), moves.c_str(), result);
 		if (err < 0)
 			return error{err};
 		m_str = result;
 		return error::OK;
 	}
 
 	error cube::transform(const std::string& trans)
 	{
 		char result[size::CUBE];
 		long long err = nissy_applytrans(
 		    m_str.c_str(), trans.c_str(), result);
 		if (err < 0)
 			return error{err};
 		m_str = result;
 		return error::OK;
 	}
 
 	void cube::invert()
 	{
 		char result[size::CUBE];
 		nissy_inverse(m_str.c_str(), result);
 		m_str = result;
 	}
 
 	std::string cube::to_string() const { return m_str; }
 
 	std::variant<cube, error>
 	cube::from_string(const std::string& str)
 	{
 		/* Check that the cube is valid by making a single move */
 		char result[size::CUBE];
 		auto err = nissy_applymoves(str.c_str(), "U", result);
 		if (err < 0)
 			return error{err};
 
 		cube c;
 		c.m_str = str;
 		return c;
 	}
 
 	std::variant<cube, error>
 	cube::get(long long ep, long long eo,
 	    long long cp, long long co, long long orien)
 	{
 		return get(ep, eo, cp, co, orien, "fix");
 	}
 
 	std::variant<cube, error>
 	cube::get(long long ep, long long eo, long long cp, long long co,
 	    long long orient, const std::string& options)
 	{
 		char result[size::CUBE];
 		cube c;
 		auto err = nissy_getcube(ep, eo, cp, co, orient,
 		    options.c_str(), result);
 		if (err < 0)
 			return error{err};
 		c.m_str = result;
 		return c;
 	}
 
 	error solver::generate_data()
 	{
 		data.resize(size);
 		auto err = nissy_gendata(name.c_str(),
 		    size, reinterpret_cast<unsigned char *>(data.data()));
 		return error{err};
 	}
 
 	void solver::read_data(std::ifstream& ifs)
 	{
 		data.resize(size);
 		ifs.read(reinterpret_cast<char *>(data.data()), size);
 	}
 
 	error solver::check_data()
 	{
 		auto err_value = nissy_checkdata(name.c_str(), data.size(),
 		    reinterpret_cast<const unsigned char *>(data.data()));
 		error err{err_value};
 		data_checked = err.ok();
 		return err;
 	}
 
 	void solver::unload_data()
 	{
 		data.resize(0);
 	}
 
 	solver::solve_result
 	solver::solve(const cube& cube, nissflag niss, unsigned minmoves,
 	    unsigned maxmoves, unsigned maxsols, unsigned optimal,
 	    unsigned threads, int (*poll_status)(void *),
 	    void *poll_status_data) const
 	{
 		long long stats[size::SOLVE_STATS];
 		solver::solve_result result;
 
 		if (maxsols == 0) {
 			result.solutions = "";
 			result.err = error::OK;
 			return result;
 		}
 
 		const size_t len = 3 * (maxmoves+1) * maxsols;
 		result.solutions.resize(len);
 
 		auto err = nissy_solve(cube.to_string().c_str(),
 		    name.c_str(), niss.value, minmoves, maxmoves, maxsols,
 		    optimal, threads, data.size(),
 		    reinterpret_cast<const unsigned char *>(data.data()), len,
 		    result.solutions.data(), stats,
 		    poll_status, poll_status_data);
 
 		int size = result.solutions.find_first_of('\0');
 		result.solutions.resize(size);
 		result.err = error{err};
 
 		return result;
 	}
 
 	std::variant<solver, error> solver::get(const std::string& name)
 	{
 		char dataid[size::DATAID];
 		auto err = nissy_solverinfo(name.c_str(), dataid);
 		if (err < 0)
 			return error{err};
 		solver s(name);
 		s.size = (unsigned)err;
 		s.id = std::string{dataid};
 		return s;
 	}
 
 	solver::solver(const std::string& str) : name{str} {}
 
 	error count_moves(const std::string& moves)
 	{
 		auto err = nissy_countmoves(moves.c_str());
 		return error{err};
 	}
 
 	std::variant<error, compare_result>
 	compare_moves(const std::string& m1, const std::string& m2)
 	{
 		auto cmp = nissy_comparemoves(m1.c_str(), m2.c_str());
 		if (cmp < 0)
 			return error{cmp};
 		else
 			return compare_result{cmp};
 	}
 
 	void set_logger(void (*log)(const char *, void *), void *data)
 	{
 		nissy_setlogger(log, data);
 	}
 }