From 321460c445e6dcdcb33c1c532e287f184a8bf9c7 Mon Sep 17 00:00:00 2001 From: Dnomd343 Date: Sun, 8 Jan 2023 13:56:14 +0800 Subject: [PATCH] feat: try rust style --- src/common_code/common_code.cc | 125 ++++++++++++++++++++++++--------- src/common_code/common_code.h | 21 +++++- src/main.cc | 19 +++-- 3 files changed, 124 insertions(+), 41 deletions(-) diff --git a/src/common_code/common_code.cc b/src/common_code/common_code.cc index 9408f27..c3c9d81 100644 --- a/src/common_code/common_code.cc +++ b/src/common_code/common_code.cc @@ -8,22 +8,89 @@ inline uint8_t last_zero_num(uint32_t bin) { // get last zero number return __builtin_popcount(bin >> 1); } -std::string CommonCode::to_string(uint64_t common_code, bool shorten) { - if (!CommonCode::check(common_code)) { - throw std::invalid_argument("invalid common code"); +//std::string CommonCode::to_string_(uint64_t common_code, bool shorten) { +// if (!CommonCode::check(common_code)) { +// throw std::invalid_argument("invalid common code"); +// } +// char result[10]; // max length 9-bits +// sprintf(result, "%09lX", common_code); +// if (shorten) { // remove `0` after common code +// if (common_code == 0x000000000) { +// return "0"; // special case +// } +// result[9 - last_zero_num(common_code) / 4] = '\0'; // truncate string +// } +// return result; +//} + +//uint64_t CommonCode::from_string_(const std::string &common_code) { +// if (common_code.length() > 9 || common_code.length() == 0) { +// throw std::invalid_argument("common code format error"); +// } +// uint64_t result = 0; +// for (auto const &bit : common_code) { +// result <<= 4; +// if (bit >= '0' && bit <= '9') { // 0 ~ 9 +// result |= (bit - 48); +// } else if (bit >= 'A' && bit <= 'Z') { // A ~ Z +// result |= (bit - 55); +// } else if (bit >= 'a' && bit <= 'z') { // a ~ z +// result |= (bit - 87); +// } else { +// throw std::invalid_argument("common code format error"); +// } +// } +// // TODO: should we ensure that common code is valid? +// return result << (9 - common_code.length()) * 4; // low-bits fill with zero +//} + +bool CommonCode::check(uint64_t common_code) { // check whether common code is valid + uint32_t head = common_code >> 32; + if (head >= 16 || (head & 0b11) == 0b11) { // check 2x2 block address + return false; // invalid common code + } + + uint32_t fill_num = 0, space_num = 0; + auto range = Common::range_reverse((uint32_t)common_code); // get common code range + for (int i = 0; i < 32; i += 2) { // traverse range + switch ((range >> i) & 0b11) { + case 0b00: // space block + ++space_num; + case 0b11: // 1x1 block + ++fill_num; + break; + case 0b01: // 1x2 block + case 0b10: // 2x1 block + fill_num += 2; + } + if (fill_num >= 16) { // all block filled + break; + } + } + if (space_num < 2) { + return false; // at least 2 space } + return Common::check_case(head, range); // check by head and range +} + +std::string CommonCode::to_string(bool shorten) const { + char result[10]; // max length 9-bits - sprintf(result, "%09lX", common_code); + sprintf(result, "%09lX", code); if (shorten) { // remove `0` after common code - if (common_code == 0x000000000) { + if (code == 0x000000000) { return "0"; // special case } - result[9 - last_zero_num(common_code) / 4] = '\0'; // truncate string + result[9 - last_zero_num(code) / 4] = '\0'; // truncate string } return result; + +// return CommonCode::to_string_(code, shorten); + } -uint64_t CommonCode::from_string(const std::string &common_code) { +CommonCode CommonCode::from_string(const std::string &common_code) { + if (common_code.length() > 9 || common_code.length() == 0) { throw std::invalid_argument("common code format error"); } @@ -40,35 +107,27 @@ uint64_t CommonCode::from_string(const std::string &common_code) { throw std::invalid_argument("common code format error"); } } + + return CommonCode(result << (9 - common_code.length()) * 4); // low-bits fill with zero + // TODO: should we ensure that common code is valid? - return result << (9 - common_code.length()) * 4; // low-bits fill with zero +// return result << (9 - common_code.length()) * 4; // low-bits fill with zero + + +// return CommonCode(CommonCode::from_string_(common_code)); + } -bool CommonCode::check(uint64_t common_code) { // check whether common code is valid - uint32_t head = common_code >> 32; - if (head >= 16 || (head & 0b11) == 0b11) { // check 2x2 block address - return false; // invalid common code - } +CommonCode::CommonCode(uint64_t common_code) { - uint32_t fill_num = 0, space_num = 0; - auto range = Common::range_reverse((uint32_t)common_code); // get common code range - for (int i = 0; i < 32; i += 2) { // traverse range - switch ((range >> i) & 0b11) { - case 0b00: // space block - ++space_num; - case 0b11: // 1x1 block - ++fill_num; - break; - case 0b01: // 1x2 block - case 0b10: // 2x1 block - fill_num += 2; - } - if (fill_num >= 16) { // all block filled - break; - } - } - if (space_num < 2) { - return false; // at least 2 space + if (!CommonCode::check(common_code)) { + throw std::invalid_argument("invalid common code"); } - return Common::check_case(head, range); // check by head and range + + code = common_code; + +} + +uint64_t CommonCode::unwrap() const { + return code; } diff --git a/src/common_code/common_code.h b/src/common_code/common_code.h index 614886a..8148c93 100644 --- a/src/common_code/common_code.h +++ b/src/common_code/common_code.h @@ -5,7 +5,24 @@ class CommonCode { public: + + explicit CommonCode(uint64_t common_code); + + uint64_t unwrap() const; + + std::string to_string(bool shorten = false) const; + + static CommonCode from_string(const std::string &common_code); + + +private: + + uint64_t code; + static bool check(uint64_t common_code); - static uint64_t from_string(const std::string &common_code); - static std::string to_string(uint64_t common_code, bool shorten = false); + +// static uint64_t from_string(const std::string &common_code); +// static std::string to_string(uint64_t common_code, bool shorten = false); + + }; diff --git a/src/main.cc b/src/main.cc index b6c7339..98b159e 100644 --- a/src/main.cc +++ b/src/main.cc @@ -45,13 +45,20 @@ int main() { // std::cout << AllCases::get_basic_ranges() << std::endl; - std::cout << CommonCode::check(0x123456789) << std::endl; - std::cout << CommonCode::check(0x4FEA13400) << std::endl; +// std::cout << CommonCode::check(0x123456789) << std::endl; +// std::cout << CommonCode::check(0x4FEA13400) << std::endl; +// +// // TODO: should we return a CommonCode object like String::new(...) in rust? +// printf("%09lX\n", CommonCode::from_string("1A9bF0c0")); +// std::cout << CommonCode::to_string(0x1A9BF0C00) << std::endl; +// std::cout << CommonCode::to_string(0x1A9BF0C00, true) << std::endl; + + auto c = CommonCode::from_string("1A9bF0c0"); + std::cout << c.to_string(true) << std::endl; + std::cout << c.to_string() << std::endl; + printf("%09lX\n", c.unwrap()); - // TODO: should we return a CommonCode object like String::new(...) in rust? - printf("%09lX\n", CommonCode::from_string("1A9bF0c0")); - std::cout << CommonCode::to_string(0x1A9BF0C00) << std::endl; - std::cout << CommonCode::to_string(0x1A9BF0C00, true) << std::endl; + std::cout << CommonCode(0x1A9BF0C00).to_string() << std::endl; return 0; }