1 files changed, 133 insertions, 0 deletions

diff --git a/cpp/nissy.h b/cpp/nissy.h
new file mode 100644
index 0000000..e336c7a
--- /dev/null
+++ b/cpp/nissy.h
@@ -0,0 +1,133 @@
+/*
+C++20 header file for nissy.
+*/
+
+#ifndef NISSY_H
+#define NISSY_H
+
+#include <array>
+#include <functional>
+#include <optional>
+#include <ranges>
+#include <string>
+#include <string_view>
+#include <variant>
+#include <vector>
+
+namespace nissy {
+        /* Some constants for size for I/O buffers */
+        namespace size {
+                constexpr size_t B32 = 22;
+                constexpr size_t H48 = 88;
+                constexpr size_t CUBE_MAX = H48;
+                constexpr size_t TRANSFORMATION = 12;
+                constexpr size_t SOLVE_STATS = 10;
+                constexpr size_t DATAID = 255;
+        }
+
+        /* Some structs definitions for better type safety */
+        struct nissflag_t { unsigned value; };
+        struct error_t { long long value; };
+        struct cube_t { std::string value; };
+        struct moves_t { std::string value; };
+        struct trans_t { std::string value; };
+        struct cube_format_t { std::string value; };
+        struct solver_t { std::string value; };
+        struct solver_data_t { std::vector<std::byte> value; };
+        struct solve_result_t {
+                std::vector<std::string> solutions;
+                std::array<long long, size::SOLVE_STATS> stats;
+        };
+
+        /* Flags for NISS options */
+        namespace nissflag {
+                constexpr nissflag_t NORMAL{1};
+                constexpr nissflag_t INVERSE{2};
+                constexpr nissflag_t MIXED{4};
+                constexpr nissflag_t LINEAR{NORMAL.value | INVERSE.value};
+                constexpr nissflag_t ALL{LINEAR.value | MIXED.value};
+        }
+
+        /* Error codes */
+        namespace error {
+                constexpr error_t UNSOLVABLE{-1};
+                constexpr error_t INVALID_CUBE{-10};
+                constexpr error_t UNSOLVABLE_CUBE{-11};
+                constexpr error_t INVALID_MOVES{-20};
+                constexpr error_t INVALID_TRANS{-30};
+                constexpr error_t INVALID_FORMAT{-40};
+                constexpr error_t INVALID_SOLVER{-50};
+                constexpr error_t NULL_POINTER{-60};
+                constexpr error_t BUFFER_SIZE{-61};
+                constexpr error_t DATA{-70};
+                constexpr error_t OPTIONS{-80};
+                constexpr error_t UNKNOWN{-999};
+        }
+
+        /* Cube constants */
+        namespace cube {
+                const cube_t SOLVED{"ABCDEFGH=ABCDEFGHIJKL"};
+        }
+
+        std::variant<cube_t, error_t> inverse(
+                const cube_t& cube
+        );
+
+        std::variant<cube_t, error_t> applymoves(
+                const cube_t& cube,
+                const moves_t& moves
+        );
+
+        std::variant<cube_t, error_t> applytrans(
+                const cube_t& cube,
+                const trans_t& trans
+        );
+
+        std::variant<std::string, error_t> convert(
+                const cube_format_t& format_in,
+                const cube_format_t& format_out,
+                const std::string& cube_string
+        );
+
+        std::variant<cube_t, error_t> getcube(
+                long long ep,
+                long long eo,
+                long long cp,
+                long long co,
+                const std::string& options
+        );
+
+        std::variant<std::pair<size_t, std::string>, error_t> solverinfo(
+                const solver_t& solver
+        );
+
+        std::variant<solver_data_t, error_t> gendata(
+                const solver_t& solver
+        );
+
+        std::optional<error_t> checkdata(
+                const solver_data_t& data
+        );
+
+        std::variant<solve_result_t, error_t> solve(
+                const cube_t& cube,
+                const solver_t& solver,
+                nissflag_t niss,
+                unsigned minmoves,
+                unsigned maxmoves,
+                unsigned maxsolutions,
+                int optimal,
+                int threads,
+                const solver_data_t& data
+        );
+
+        std::variant<unsigned, error_t> countmoves(
+                const moves_t& moves
+        );
+
+        void setlogger(
+                std::function<void(std::string&)> log
+        );
+}
+
+#endif