dnomd343
/
klotski
mirror of https://github.com/dnomd343/klotski.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

update: cleanup inline functions of raw code

legacy
Dnomd343 8 months ago
parent
49ae5ba46f
commit
424bdefbc5
7 changed files with 87 additions and 111 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 1
      src/core/CMakeLists.txt
  2. 4
      src/core/raw_code/internal/convert.cc
  3. 20
      src/core/raw_code/internal/mirror.cc
  4. 8
      src/core/raw_code/internal/raw_code.cc
  5. 72
      src/core/raw_code/internal/raw_code.inl
  6. 40
      src/core/raw_code/internal/sundry.cc
  7. 51
      src/core/raw_code/raw_code.h

1
src/core/CMakeLists.txt
View File

@ -12,7 +12,6 @@ set(KLOTSKI_CORE_SRC
raw_code/internal/raw_code.cc raw_code/internal/raw_code.cc
raw_code/internal/convert.cc raw_code/internal/convert.cc
raw_code/internal/sundry.cc
raw_code/internal/mirror.cc raw_code/internal/mirror.cc
short_code/internal/convert.cc short_code/internal/convert.cc

4
src/core/raw_code/internal/convert.cc
View File

@ -2,7 +2,7 @@
#include "utils/utility.h" #include "utils/utility.h"
#include "raw_code/raw_code.h" #include "raw_code/raw_code.h"
namespace klotski::codec { using klotski::codec::RawCode;
uint64_t RawCode::compact(uint64_t raw_code) { uint64_t RawCode::compact(uint64_t raw_code) {
int unfilled = 16; int unfilled = 16;
@ -57,5 +57,3 @@ uint64_t RawCode::extract(uint64_t common_code) {
} }
return code; return code;
} }
} // namespace klotski::codec

20
src/core/raw_code/internal/mirror.cc
View File

@ -1,9 +1,7 @@
#include "utils/common.h" #include "utils/common.h"
#include "raw_code/raw_code.h" #include "raw_code/raw_code.h"
namespace klotski::codec { using klotski::codec::RawCode;
// ----------------------------------------------------------------------------------------- //
/// MASK_MIRROR_H1 | MASK_MIRROR_H2 /// MASK_MIRROR_H1 | MASK_MIRROR_H2
/// 111 000 000 000 | 000 111 000 000 /// 111 000 000 000 | 000 111 000 000
@ -26,9 +24,7 @@ constexpr uint64_t MASK_MIRROR_V1 = 0x0'000'000'000'000'FFF;
constexpr uint64_t MASK_MIRROR_V2 = 0x0'000'000'000'FFF'000; constexpr uint64_t MASK_MIRROR_V2 = 0x0'000'000'000'FFF'000;
constexpr uint64_t MASK_MIRROR_V3 = 0x0'000'000'FFF'000'000; constexpr uint64_t MASK_MIRROR_V3 = 0x0'000'000'FFF'000'000;
// ----------------------------------------------------------------------------------------- // static void vertical_fill(uint64_t &raw_code) {
inline static void vertical_fill(uint64_t &raw_code) {
uint64_t mask = 0; uint64_t mask = 0;
for (int addr = 0; addr < 60; addr += 3) { // traverse every 3-bit for (int addr = 0; addr < 60; addr += 3) { // traverse every 3-bit
switch ((raw_code >> addr) & 0b111) { switch ((raw_code >> addr) & 0b111) {
@ -49,7 +45,7 @@ inline static void vertical_fill(uint64_t &raw_code) {
} }
} }
inline static void horizontal_fill(uint64_t &raw_code) { static void horizontal_fill(uint64_t &raw_code) {
for (int addr = 0; addr < 60; addr += 3) { // traverse every 3-bit for (int addr = 0; addr < 60; addr += 3) { // traverse every 3-bit
switch ((raw_code >> addr) & 0b111) { switch ((raw_code >> addr) & 0b111) {
case BLOCK_1x2: case BLOCK_1x2:
@ -64,7 +60,7 @@ inline static void horizontal_fill(uint64_t &raw_code) {
} }
} }
inline static void vertical_clear(uint64_t &raw_code) { static void vertical_clear(uint64_t &raw_code) {
for (int addr = 0; addr < 60; addr += 3) { // traverse every 3-bit for (int addr = 0; addr < 60; addr += 3) { // traverse every 3-bit
switch ((raw_code >> addr) & 0b111) { switch ((raw_code >> addr) & 0b111) {
case BLOCK_2x1: case BLOCK_2x1:
@ -74,7 +70,7 @@ inline static void vertical_clear(uint64_t &raw_code) {
} }
} }
inline static void horizontal_clear(uint64_t &raw_code) { static void horizontal_clear(uint64_t &raw_code) {
for (int addr = 0; addr < 60; addr += 3) { // traverse every 3-bit for (int addr = 0; addr < 60; addr += 3) { // traverse every 3-bit
switch ((raw_code >> addr) & 0b111) { switch ((raw_code >> addr) & 0b111) {
case BLOCK_1x2: case BLOCK_1x2:
@ -84,8 +80,6 @@ inline static void horizontal_clear(uint64_t &raw_code) {
} }
} }
// ----------------------------------------------------------------------------------------- //
uint64_t RawCode::get_vertical_mirror(uint64_t raw_code) { uint64_t RawCode::get_vertical_mirror(uint64_t raw_code) {
vertical_fill(raw_code); vertical_fill(raw_code);
raw_code = (raw_code & MASK_MIRROR_V3) raw_code = (raw_code & MASK_MIRROR_V3)
@ -114,7 +108,3 @@ bool RawCode::check_horizontal_mirror(uint64_t raw_code) {
return !(MASK_MIRROR_H1 & ((raw_code >> 9) ^ raw_code)) return !(MASK_MIRROR_H1 & ((raw_code >> 9) ^ raw_code))
&& !(MASK_MIRROR_H2 & ((raw_code >> 3) ^ raw_code)); && !(MASK_MIRROR_H2 & ((raw_code >> 3) ^ raw_code));
} }
// ----------------------------------------------------------------------------------------- //
} // namespace klotski::codec

8
src/core/raw_code/internal/raw_code.cc
View File

@ -1,9 +1,10 @@
#include "utils/common.h" #include "utils/common.h"
#include "raw_code/raw_code.h" #include "raw_code/raw_code.h"
namespace klotski::codec { using klotski::codec::RawCode;
std::ostream& operator<<(std::ostream &out, const RawCode self) { #ifndef KLSK_NDEBUG
std::ostream& klotski::codec::operator<<(std::ostream &out, const RawCode self) {
char *code; char *code;
asprintf(&code, "%015llX\n", self.code_); // code length -> 15 asprintf(&code, "%015llX\n", self.code_); // code length -> 15
out << code; out << code;
@ -19,6 +20,7 @@ std::ostream& operator<<(std::ostream &out, const RawCode self) {
} }
return out; return out;
} }
#endif
bool RawCode::check(uint64_t raw_code) { bool RawCode::check(uint64_t raw_code) {
/// MASK_1x1 | MASK_1x2 | MASK_2x1 | MASK_2x2 /// MASK_1x1 | MASK_1x2 | MASK_2x1 | MASK_2x2
@ -68,5 +70,3 @@ bool RawCode::check(uint64_t raw_code) {
} }
return head_num == 1 && space_num >= 2; // one head and at least 2 space return head_num == 1 && space_num >= 2; // one head and at least 2 space
} }
} // namespace klotski::codec

72
src/core/raw_code/internal/raw_code.inl
View File

@ -2,47 +2,59 @@
#include <bit> #include <bit>
#include "common_code/common_code.h"
namespace klotski::codec { namespace klotski::codec {
// ------------------------------------------------------------------------------------- // // ------------------------------------------------------------------------------------- //
inline uint64_t RawCode::unwrap() const { inline RawCode::RawCode(const CommonCode common_code) {
return code_; code_ = extract(common_code.unwrap());
} }
inline RawCode::operator uint64_t() const { inline RawCode RawCode::unsafe_create(const uint64_t raw_code) {
return code_; return std::bit_cast<RawCode>(raw_code); // init directly
} }
// ------------------------------------------------------------------------------------- // inline std::optional<RawCode> RawCode::create(const uint64_t raw_code) {
if (!check(raw_code)) {
constexpr auto operator==(const RawCode &lhs, const uint64_t rhs) { return std::nullopt; // invalid raw code
return lhs.code_ == rhs; }
return unsafe_create(raw_code);
} }
constexpr auto operator<=>(const RawCode &lhs, const uint64_t rhs) { // ------------------------------------------------------------------------------------- //
return lhs.code_ <=> rhs;
inline RawCode::operator uint64_t() const {
return code_;
} }
constexpr auto operator==(const RawCode &lhs, const RawCode &rhs) { inline uint64_t RawCode::unwrap() const {
return lhs.code_ == rhs.code_; return code_;
} }
constexpr auto operator<=>(const RawCode &lhs, const RawCode &rhs) { inline CommonCode RawCode::to_common_code() const {
return lhs.code_ <=> rhs.code_; return CommonCode::unsafe_create(compact(code_));
} }
// ------------------------------------------------------------------------------------- // // ------------------------------------------------------------------------------------- //
inline RawCode RawCode::unsafe_create(const uint64_t raw_code) { inline RawCode RawCode::from_common_code(const CommonCode common_code) {
return std::bit_cast<RawCode>(raw_code); // init directly return common_code.to_raw_code();
} }
inline std::optional<RawCode> RawCode::create(const uint64_t raw_code) { inline std::optional<RawCode> RawCode::from_common_code(const uint64_t common_code) {
if (!check(raw_code)) { const auto convert = [](const CommonCode code) {
return std::nullopt; // invalid raw code return code.to_raw_code();
} };
return unsafe_create(raw_code); return CommonCode::create(common_code).transform(convert);
}
inline std::optional<RawCode> RawCode::from_common_code(const std::string &common_code) {
const auto convert = [](const CommonCode code) {
return code.to_raw_code();
};
return CommonCode::from_string(common_code).transform(convert);
} }
// ------------------------------------------------------------------------------------- // // ------------------------------------------------------------------------------------- //
@ -73,4 +85,22 @@ inline bool RawCode::is_horizontal_mirror(const RawCode raw_code) const {
// ------------------------------------------------------------------------------------- // // ------------------------------------------------------------------------------------- //
constexpr auto operator==(const RawCode &lhs, const uint64_t rhs) {
return lhs.code_ == rhs;
}
constexpr auto operator<=>(const RawCode &lhs, const uint64_t rhs) {
return lhs.code_ <=> rhs;
}
constexpr auto operator==(const RawCode &lhs, const RawCode &rhs) {
return lhs.code_ == rhs.code_;
}
constexpr auto operator<=>(const RawCode &lhs, const RawCode &rhs) {
return lhs.code_ <=> rhs.code_;
}
// ------------------------------------------------------------------------------------- //
} // namespace klotski::codec } // namespace klotski::codec

40
src/core/raw_code/internal/sundry.cc
View File

@ -1,40 +0,0 @@
#include "raw_code.h"
#include "common_code.h"
namespace klotski::codec {
// ----------------------------------------------------------------------------------------- //
RawCode::RawCode(const CommonCode common_code) {
code_ = extract(common_code.unwrap());
}
// ----------------------------------------------------------------------------------------- //
CommonCode RawCode::to_common_code() const {
return CommonCode::unsafe_create(compact(code_));
}
// ----------------------------------------------------------------------------------------- //
RawCode RawCode::from_common_code(const CommonCode common_code) {
return common_code.to_raw_code();
}
std::optional<RawCode> RawCode::from_common_code(const uint64_t common_code) {
auto convert = [](const CommonCode code) {
return code.to_raw_code();
};
return CommonCode::create(common_code).transform(convert);
}
std::optional<RawCode> RawCode::from_common_code(const std::string &common_code) {
auto convert = [](const CommonCode code) {
return code.to_raw_code();
};
return CommonCode::from_string(common_code).transform(convert);
}
// ----------------------------------------------------------------------------------------- //
} // namespace klotski::codec

51
src/core/raw_code/raw_code.h
View File

@ -74,15 +74,29 @@ class RawCode {
public: public:
// ------------------------------------------------------------------------------------- // // ------------------------------------------------------------------------------------- //
RawCode() = delete;
/// Construct RawCode from CommonCode.
explicit RawCode(CommonCode common_code);
/// Create RawCode without any check.
static RawCode unsafe_create(uint64_t raw_code);
/// Create RawCode with validity check.
static std::optional<RawCode> create(uint64_t raw_code);
// ------------------------------------------------------------------------------------- //
/// Explicit conversion to u64 code. /// Explicit conversion to u64 code.
explicit operator uint64_t() const; explicit operator uint64_t() const;
/// Check the validity of the original RawCode. /// Check the validity of the original RawCode.
static bool check(uint64_t raw_code); static bool check(uint64_t raw_code);
// TODO: add macro check here #ifndef KLSK_NDEBUG
/// Output string encoding of RawCode only for debug. /// Output string encoding of RawCode only for debug.
friend std::ostream& operator<<(std::ostream &out, RawCode self); friend std::ostream& operator<<(std::ostream &out, RawCode self);
#endif
// ------------------------------------------------------------------------------------- // // ------------------------------------------------------------------------------------- //
@ -94,19 +108,6 @@ public:
// ------------------------------------------------------------------------------------- // // ------------------------------------------------------------------------------------- //
RawCode() = delete;
/// Construct RawCode from CommonCode.
explicit RawCode(CommonCode common_code);
/// Create RawCode without any check.
static RawCode unsafe_create(uint64_t raw_code);
/// Create RawCode with validity check.
static std::optional<RawCode> create(uint64_t raw_code);
// ------------------------------------------------------------------------------------- //
/// Create RawCode from CommonCode. /// Create RawCode from CommonCode.
static RawCode from_common_code(CommonCode common_code); static RawCode from_common_code(CommonCode common_code);
@ -118,24 +119,12 @@ public:
// ------------------------------------------------------------------------------------- // // ------------------------------------------------------------------------------------- //
/// Compare RawCode with u64 values.
friend constexpr auto operator==(const RawCode &lhs, uint64_t rhs);
friend constexpr auto operator<=>(const RawCode &lhs, uint64_t rhs);
/// Compare the original values of two RawCodes.
friend constexpr auto operator==(const RawCode &lhs, const RawCode &rhs);
friend constexpr auto operator<=>(const RawCode &lhs, const RawCode &rhs);
// ------------------------------------------------------------------------------------- //
/// Calculate vertically symmetrical layout. /// Calculate vertically symmetrical layout.
[[nodiscard]] RawCode to_vertical_mirror() const; [[nodiscard]] RawCode to_vertical_mirror() const;
/// Calculate horizontally symmetrical layout. /// Calculate horizontally symmetrical layout.
[[nodiscard]] RawCode to_horizontal_mirror() const; [[nodiscard]] RawCode to_horizontal_mirror() const;
// ------------------------------------------------------------------------------------- //
/// Determine whether the layout is vertically symmetrical. /// Determine whether the layout is vertically symmetrical.
[[nodiscard]] bool is_vertical_mirror() const; [[nodiscard]] bool is_vertical_mirror() const;
@ -150,6 +139,16 @@ public:
// ------------------------------------------------------------------------------------- // // ------------------------------------------------------------------------------------- //
/// Compare RawCode with u64 value.
friend constexpr auto operator==(const RawCode &lhs, uint64_t rhs);
friend constexpr auto operator<=>(const RawCode &lhs, uint64_t rhs);
/// Compare the original values of two RawCodes.
friend constexpr auto operator==(const RawCode &lhs, const RawCode &rhs);
friend constexpr auto operator<=>(const RawCode &lhs, const RawCode &rhs);
// ------------------------------------------------------------------------------------- //
private: private:
uint64_t code_; uint64_t code_;

Write Preview
Loading…
Cancel
Save