From ce0fee076fc4ed948e53a8a3f0230ad10213bd82 Mon Sep 17 00:00:00 2001 From: ramon-bernardo Date: Thu, 5 Sep 2024 22:15:22 -0300 Subject: [PATCH 01/24] Wildcard tree search enhancement and tests --- src/game.cpp | 17 ++++--- src/tests/test_generate_token.cpp | 2 +- src/tests/test_sha1.cpp | 2 +- src/tests/test_wildcard_tree.cpp | 54 ++++++++++++++++++++++ src/wildcardtree.cpp | 76 +++++++++++++++---------------- src/wildcardtree.h | 17 +++++-- 6 files changed, 116 insertions(+), 52 deletions(-) create mode 100644 src/tests/test_wildcard_tree.cpp diff --git a/src/game.cpp b/src/game.cpp index 7b10f38afa..17529dd83f 100644 --- a/src/game.cpp +++ b/src/game.cpp @@ -463,14 +463,17 @@ ReturnValue Game::getPlayerByNameWildcard(const std::string& s, Player*& player) } if (s.back() == '~') { - const std::string& query = boost::algorithm::to_lower_copy(s.substr(0, strlen - 1)); - std::string result; - ReturnValue ret = wildcardTree.findOne(query, result); - if (ret != RETURNVALUE_NOERROR) { - return ret; + const auto& query = boost::algorithm::to_lower_copy(s.substr(0, strlen - 1)); + auto searchResult = wildcardTree.search(query); + switch (searchResult.first) { + case WildcardTreeNode::NotFound: + return RETURNVALUE_PLAYERWITHTHISNAMEISNOTONLINE; + case WildcardTreeNode::Ambiguous: + return RETURNVALUE_NAMEISTOOAMBIGUOUS; + case WildcardTreeNode::Found: + player = getPlayerByName(searchResult.second); + break; } - - player = getPlayerByName(result); } else { player = getPlayerByName(s); } diff --git a/src/tests/test_generate_token.cpp b/src/tests/test_generate_token.cpp index ff9d97ddf8..399fa63090 100644 --- a/src/tests/test_generate_token.cpp +++ b/src/tests/test_generate_token.cpp @@ -1,4 +1,4 @@ -#define BOOST_TEST_MODULE rsa +#define BOOST_TEST_MODULE generate_token #include "../otpch.h" diff --git a/src/tests/test_sha1.cpp b/src/tests/test_sha1.cpp index dddac776f9..9cffa4b741 100644 --- a/src/tests/test_sha1.cpp +++ b/src/tests/test_sha1.cpp @@ -1,4 +1,4 @@ -#define BOOST_TEST_MODULE rsa +#define BOOST_TEST_MODULE sha1 #include "../otpch.h" diff --git a/src/tests/test_wildcard_tree.cpp b/src/tests/test_wildcard_tree.cpp new file mode 100644 index 0000000000..42f7adba51 --- /dev/null +++ b/src/tests/test_wildcard_tree.cpp @@ -0,0 +1,54 @@ +#define BOOST_TEST_MODULE wildcard_tree + +#include "../otpch.h" + +#include "../wildcardtree.h" + +#include + +BOOST_AUTO_TEST_CASE(test_wildcard_tree_single_words) +{ + WildcardTreeNode root(false); + + root.insert("test"); + + BOOST_CHECK_EQUAL(root.search("tes").first, WildcardTreeNode::NotFound); + BOOST_CHECK_EQUAL(root.search("test").first, WildcardTreeNode::Found); + BOOST_CHECK_EQUAL(root.search("testing").first, WildcardTreeNode::NotFound); +} + +BOOST_AUTO_TEST_CASE(test_wildcard_tree_ambiguity) +{ + WildcardTreeNode root(false); + + root.insert("test"); + root.insert("te"); + + BOOST_CHECK_EQUAL(root.search("te").first, WildcardTreeNode::Ambiguous); + BOOST_CHECK_EQUAL(root.search("test").first, WildcardTreeNode::Found); +} + +BOOST_AUTO_TEST_CASE(test_wildcard_tree_remove) +{ + WildcardTreeNode root(false); + + root.insert("test"); + BOOST_CHECK_EQUAL(root.search("test").first, WildcardTreeNode::Found); + + root.remove("test"); + BOOST_CHECK_EQUAL(root.search("test").first, WildcardTreeNode::NotFound); +} + +BOOST_AUTO_TEST_CASE(test_wildcard_tree_partial_search) +{ + WildcardTreeNode root(false); + root.insert("test"); + root.insert("te"); + + BOOST_CHECK_EQUAL(root.search("te").first, WildcardTreeNode::Ambiguous); + BOOST_CHECK_EQUAL(root.search("test").first, WildcardTreeNode::Found); + + root.remove("test"); + BOOST_CHECK_EQUAL(root.search("te").first, WildcardTreeNode::Found); + BOOST_CHECK_EQUAL(root.search("test").first, WildcardTreeNode::NotFound); +} diff --git a/src/wildcardtree.cpp b/src/wildcardtree.cpp index d274d8a953..672b9ee015 100644 --- a/src/wildcardtree.cpp +++ b/src/wildcardtree.cpp @@ -28,87 +28,87 @@ const WildcardTreeNode* WildcardTreeNode::getChild(char ch) const WildcardTreeNode* WildcardTreeNode::addChild(char ch, bool breakpoint) { - WildcardTreeNode* child = getChild(ch); - if (child) { + if (auto child = getChild(ch)) { if (breakpoint && !child->breakpoint) { child->breakpoint = true; } - } else { - auto pair = - children.emplace(std::piecewise_construct, std::forward_as_tuple(ch), std::forward_as_tuple(breakpoint)); - child = &pair.first->second; + return child; } - return child; + + auto pair = + children.emplace(std::piecewise_construct, std::forward_as_tuple(ch), std::forward_as_tuple(breakpoint)); + return &pair.first->second; } void WildcardTreeNode::insert(const std::string& str) { - WildcardTreeNode* cur = this; + auto node = this; - size_t length = str.length() - 1; + auto length = str.length() - 1; for (size_t pos = 0; pos < length; ++pos) { - cur = cur->addChild(str[pos], false); + node = node->addChild(str[pos], false); } - - cur->addChild(str[length], true); + node->addChild(str[length], true); } void WildcardTreeNode::remove(const std::string& str) { - WildcardTreeNode* cur = this; + auto node = this; std::stack path; - path.push(cur); - size_t len = str.length(); + path.push(node); + + auto len = str.length(); for (size_t pos = 0; pos < len; ++pos) { - cur = cur->getChild(str[pos]); - if (!cur) { + node = node->getChild(str[pos]); + if (!node) { return; } - path.push(cur); + path.push(node); } - cur->breakpoint = false; + node->breakpoint = false; do { - cur = path.top(); + node = path.top(); path.pop(); - if (!cur->children.empty() || cur->breakpoint || path.empty()) { + if (!node->children.empty() || node->breakpoint || path.empty()) { break; } - cur = path.top(); + node = path.top(); - auto it = cur->children.find(str[--len]); - if (it != cur->children.end()) { - cur->children.erase(it); + auto it = node->children.find(str[--len]); + if (it != node->children.end()) { + node->children.erase(it); } } while (true); } -ReturnValue WildcardTreeNode::findOne(const std::string& query, std::string& result) const +std::pair WildcardTreeNode::search(const std::string& query) const { - const WildcardTreeNode* cur = this; - for (char pos : query) { - cur = cur->getChild(pos); - if (!cur) { - return RETURNVALUE_PLAYERWITHTHISNAMEISNOTONLINE; + auto node = this; + + for (auto c : query) { + node = node->getChild(c); + if (!node) { + return std::make_pair(NotFound, ""); } } - result = query; + auto result = query; do { - size_t size = cur->children.size(); + auto size = node->children.size(); if (size == 0) { - return RETURNVALUE_NOERROR; - } else if (size > 1 || cur->breakpoint) { - return RETURNVALUE_NAMEISTOOAMBIGUOUS; + return std::make_pair(Found, result); + } else if (size > 1 || node->breakpoint) { + return std::make_pair(Ambiguous, ""); } - auto it = cur->children.begin(); + auto it = node->children.begin(); result += it->first; - cur = &it->second; + node = &it->second; } while (true); } diff --git a/src/wildcardtree.h b/src/wildcardtree.h index b8c99a1e92..c48a5e3e83 100644 --- a/src/wildcardtree.h +++ b/src/wildcardtree.h @@ -9,6 +9,13 @@ class WildcardTreeNode { public: + enum SearchResult + { + Found, + NotFound, + Ambiguous, + }; + explicit WildcardTreeNode(bool breakpoint) : breakpoint(breakpoint) {} WildcardTreeNode(WildcardTreeNode&& other) = default; @@ -16,16 +23,16 @@ class WildcardTreeNode WildcardTreeNode(const WildcardTreeNode&) = delete; WildcardTreeNode& operator=(const WildcardTreeNode&) = delete; - WildcardTreeNode* getChild(char ch); - const WildcardTreeNode* getChild(char ch) const; - WildcardTreeNode* addChild(char ch, bool breakpoint); - void insert(const std::string& str); void remove(const std::string& str); - ReturnValue findOne(const std::string& query, std::string& result) const; + std::pair search(const std::string& query) const; private: + WildcardTreeNode* getChild(char ch); + const WildcardTreeNode* getChild(char ch) const; + WildcardTreeNode* addChild(char ch, bool breakpoint); + std::map children; bool breakpoint; }; From 0a3b8c187cf3b2b13a4e98411eb53da30e78e651 Mon Sep 17 00:00:00 2001 From: ramon-bernardo Date: Thu, 5 Sep 2024 22:23:06 -0300 Subject: [PATCH 02/24] Add tests for the wildcard (second) result --- src/tests/test_wildcard_tree.cpp | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/tests/test_wildcard_tree.cpp b/src/tests/test_wildcard_tree.cpp index 42f7adba51..06d2388642 100644 --- a/src/tests/test_wildcard_tree.cpp +++ b/src/tests/test_wildcard_tree.cpp @@ -14,6 +14,7 @@ BOOST_AUTO_TEST_CASE(test_wildcard_tree_single_words) BOOST_CHECK_EQUAL(root.search("tes").first, WildcardTreeNode::NotFound); BOOST_CHECK_EQUAL(root.search("test").first, WildcardTreeNode::Found); + BOOST_CHECK_EQUAL(root.search("test").second, "test"); BOOST_CHECK_EQUAL(root.search("testing").first, WildcardTreeNode::NotFound); } @@ -26,6 +27,7 @@ BOOST_AUTO_TEST_CASE(test_wildcard_tree_ambiguity) BOOST_CHECK_EQUAL(root.search("te").first, WildcardTreeNode::Ambiguous); BOOST_CHECK_EQUAL(root.search("test").first, WildcardTreeNode::Found); + BOOST_CHECK_EQUAL(root.search("test").second, "test"); } BOOST_AUTO_TEST_CASE(test_wildcard_tree_remove) @@ -34,6 +36,7 @@ BOOST_AUTO_TEST_CASE(test_wildcard_tree_remove) root.insert("test"); BOOST_CHECK_EQUAL(root.search("test").first, WildcardTreeNode::Found); + BOOST_CHECK_EQUAL(root.search("test").second, "test"); root.remove("test"); BOOST_CHECK_EQUAL(root.search("test").first, WildcardTreeNode::NotFound); @@ -47,8 +50,10 @@ BOOST_AUTO_TEST_CASE(test_wildcard_tree_partial_search) BOOST_CHECK_EQUAL(root.search("te").first, WildcardTreeNode::Ambiguous); BOOST_CHECK_EQUAL(root.search("test").first, WildcardTreeNode::Found); + BOOST_CHECK_EQUAL(root.search("test").second, "test"); root.remove("test"); BOOST_CHECK_EQUAL(root.search("te").first, WildcardTreeNode::Found); + BOOST_CHECK_EQUAL(root.search("te").second, "te"); BOOST_CHECK_EQUAL(root.search("test").first, WildcardTreeNode::NotFound); } From b119bff3025f322b5821d126715aa92bdbde6f3c Mon Sep 17 00:00:00 2001 From: ramon-bernardo Date: Thu, 5 Sep 2024 22:38:55 -0300 Subject: [PATCH 03/24] Add search after remove test --- src/tests/test_wildcard_tree.cpp | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/src/tests/test_wildcard_tree.cpp b/src/tests/test_wildcard_tree.cpp index 06d2388642..1ff71a16ab 100644 --- a/src/tests/test_wildcard_tree.cpp +++ b/src/tests/test_wildcard_tree.cpp @@ -35,16 +35,19 @@ BOOST_AUTO_TEST_CASE(test_wildcard_tree_remove) WildcardTreeNode root(false); root.insert("test"); + BOOST_CHECK_EQUAL(root.search("test").first, WildcardTreeNode::Found); BOOST_CHECK_EQUAL(root.search("test").second, "test"); root.remove("test"); + BOOST_CHECK_EQUAL(root.search("test").first, WildcardTreeNode::NotFound); } BOOST_AUTO_TEST_CASE(test_wildcard_tree_partial_search) { WildcardTreeNode root(false); + root.insert("test"); root.insert("te"); @@ -53,7 +56,21 @@ BOOST_AUTO_TEST_CASE(test_wildcard_tree_partial_search) BOOST_CHECK_EQUAL(root.search("test").second, "test"); root.remove("test"); + BOOST_CHECK_EQUAL(root.search("te").first, WildcardTreeNode::Found); BOOST_CHECK_EQUAL(root.search("te").second, "te"); BOOST_CHECK_EQUAL(root.search("test").first, WildcardTreeNode::NotFound); } + +BOOST_AUTO_TEST_CASE(test_wildcard_tree_search_after_remove) +{ + WildcardTreeNode root(false); + + root.insert("test"); + root.insert("testing"); + root.remove("test"); + + BOOST_CHECK_EQUAL(root.search("test").first, WildcardTreeNode::NotFound); + BOOST_CHECK_EQUAL(root.search("testing").first, WildcardTreeNode::Found); + BOOST_CHECK_EQUAL(root.search("testing").second, "testing"); +} From 1f700d0c07be922a01136da88dfeb33eec81ea7d Mon Sep 17 00:00:00 2001 From: ramon-bernardo Date: Thu, 5 Sep 2024 23:00:43 -0300 Subject: [PATCH 04/24] Rename functions to snake_case and char ch to char c. --- src/game.cpp | 2 +- src/wildcardtree.cpp | 25 ++++++++++++------------- src/wildcardtree.h | 8 ++++---- 3 files changed, 17 insertions(+), 18 deletions(-) diff --git a/src/game.cpp b/src/game.cpp index 17529dd83f..84dda56ce7 100644 --- a/src/game.cpp +++ b/src/game.cpp @@ -5668,7 +5668,7 @@ void Game::addPlayer(Player* player) const std::string& lowercase_name = boost::algorithm::to_lower_copy(player->getName()); mappedPlayerNames[lowercase_name] = player; mappedPlayerGuids[player->getGUID()] = player; - wildcardTree.insert(lowercase_name); + wildcardTree.add(lowercase_name); players[player->getID()] = player; } diff --git a/src/wildcardtree.cpp b/src/wildcardtree.cpp index 672b9ee015..19b44211b9 100644 --- a/src/wildcardtree.cpp +++ b/src/wildcardtree.cpp @@ -8,47 +8,46 @@ #include #include -WildcardTreeNode* WildcardTreeNode::getChild(char ch) +WildcardTreeNode* WildcardTreeNode::find_child(char c) { - auto it = children.find(ch); + auto it = children.find(c); if (it == children.end()) { return nullptr; } return &it->second; } -const WildcardTreeNode* WildcardTreeNode::getChild(char ch) const +const WildcardTreeNode* WildcardTreeNode::find_child(char c) const { - auto it = children.find(ch); + auto it = children.find(c); if (it == children.end()) { return nullptr; } return &it->second; } -WildcardTreeNode* WildcardTreeNode::addChild(char ch, bool breakpoint) +WildcardTreeNode* WildcardTreeNode::add_child(char c, bool breakpoint) { - if (auto child = getChild(ch)) { + if (auto child = find_child(c)) { if (breakpoint && !child->breakpoint) { child->breakpoint = true; } return child; } - auto pair = - children.emplace(std::piecewise_construct, std::forward_as_tuple(ch), std::forward_as_tuple(breakpoint)); + auto pair = children.emplace(std::piecewise_construct, std::forward_as_tuple(c), std::forward_as_tuple(breakpoint)); return &pair.first->second; } -void WildcardTreeNode::insert(const std::string& str) +void WildcardTreeNode::add(const std::string& str) { auto node = this; auto length = str.length() - 1; for (size_t pos = 0; pos < length; ++pos) { - node = node->addChild(str[pos], false); + node = node->add_child(str[pos], false); } - node->addChild(str[length], true); + node->add_child(str[length], true); } void WildcardTreeNode::remove(const std::string& str) @@ -60,7 +59,7 @@ void WildcardTreeNode::remove(const std::string& str) auto len = str.length(); for (size_t pos = 0; pos < len; ++pos) { - node = node->getChild(str[pos]); + node = node->find_child(str[pos]); if (!node) { return; } @@ -91,7 +90,7 @@ std::pair WildcardTreeNode::search( auto node = this; for (auto c : query) { - node = node->getChild(c); + node = node->find_child(c); if (!node) { return std::make_pair(NotFound, ""); } diff --git a/src/wildcardtree.h b/src/wildcardtree.h index c48a5e3e83..a495bd2e1e 100644 --- a/src/wildcardtree.h +++ b/src/wildcardtree.h @@ -23,15 +23,15 @@ class WildcardTreeNode WildcardTreeNode(const WildcardTreeNode&) = delete; WildcardTreeNode& operator=(const WildcardTreeNode&) = delete; - void insert(const std::string& str); + void add(const std::string& str); void remove(const std::string& str); std::pair search(const std::string& query) const; private: - WildcardTreeNode* getChild(char ch); - const WildcardTreeNode* getChild(char ch) const; - WildcardTreeNode* addChild(char ch, bool breakpoint); + WildcardTreeNode* find_child(char c); + const WildcardTreeNode* find_child(char c) const; + WildcardTreeNode* add_child(char c, bool breakpoint); std::map children; bool breakpoint; From 1cbe651d5dc957d00cf040dfce4fd277f5a06804 Mon Sep 17 00:00:00 2001 From: ramon-bernardo Date: Thu, 5 Sep 2024 23:03:21 -0300 Subject: [PATCH 05/24] Rename str param to s --- src/wildcardtree.cpp | 16 ++++++++-------- src/wildcardtree.h | 4 ++-- 2 files changed, 10 insertions(+), 10 deletions(-) diff --git a/src/wildcardtree.cpp b/src/wildcardtree.cpp index 19b44211b9..c29fb2af84 100644 --- a/src/wildcardtree.cpp +++ b/src/wildcardtree.cpp @@ -39,27 +39,27 @@ WildcardTreeNode* WildcardTreeNode::add_child(char c, bool breakpoint) return &pair.first->second; } -void WildcardTreeNode::add(const std::string& str) +void WildcardTreeNode::add(const std::string& s) { auto node = this; - auto length = str.length() - 1; + auto length = s.length() - 1; for (size_t pos = 0; pos < length; ++pos) { - node = node->add_child(str[pos], false); + node = node->add_child(s[pos], false); } - node->add_child(str[length], true); + node->add_child(s[length], true); } -void WildcardTreeNode::remove(const std::string& str) +void WildcardTreeNode::remove(const std::string& s) { auto node = this; std::stack path; path.push(node); - auto len = str.length(); + auto len = s.length(); for (size_t pos = 0; pos < len; ++pos) { - node = node->find_child(str[pos]); + node = node->find_child(s[pos]); if (!node) { return; } @@ -78,7 +78,7 @@ void WildcardTreeNode::remove(const std::string& str) node = path.top(); - auto it = node->children.find(str[--len]); + auto it = node->children.find(s[--len]); if (it != node->children.end()) { node->children.erase(it); } diff --git a/src/wildcardtree.h b/src/wildcardtree.h index a495bd2e1e..c0d704cae3 100644 --- a/src/wildcardtree.h +++ b/src/wildcardtree.h @@ -23,8 +23,8 @@ class WildcardTreeNode WildcardTreeNode(const WildcardTreeNode&) = delete; WildcardTreeNode& operator=(const WildcardTreeNode&) = delete; - void add(const std::string& str); - void remove(const std::string& str); + void add(const std::string& s); + void remove(const std::string& s); std::pair search(const std::string& query) const; From 4292e1e1648d5f2d6762cb7c7b6e8bf7d279da3f Mon Sep 17 00:00:00 2001 From: ramon-bernardo Date: Thu, 5 Sep 2024 23:07:25 -0300 Subject: [PATCH 06/24] Add wildcard_tree test into cmake list --- src/tests/CMakeLists.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/src/tests/CMakeLists.txt b/src/tests/CMakeLists.txt index 2e6d1b1a6d..ad68e1b86c 100644 --- a/src/tests/CMakeLists.txt +++ b/src/tests/CMakeLists.txt @@ -4,6 +4,7 @@ set(tests_SRC ${CMAKE_CURRENT_LIST_DIR}/test_matrixarea.cpp ${CMAKE_CURRENT_LIST_DIR}/test_rsa.cpp ${CMAKE_CURRENT_LIST_DIR}/test_sha1.cpp + ${CMAKE_CURRENT_LIST_DIR}/test_wildcard_tree.cpp ${CMAKE_CURRENT_LIST_DIR}/test_xtea.cpp ) From 7b03a82e13df215a7aa8a72676e4afb167a0a9f8 Mon Sep 17 00:00:00 2001 From: ramon-bernardo Date: Thu, 5 Sep 2024 23:16:10 -0300 Subject: [PATCH 07/24] Rename insert function wildcard_tree test --- src/tests/test_wildcard_tree.cpp | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/src/tests/test_wildcard_tree.cpp b/src/tests/test_wildcard_tree.cpp index 1ff71a16ab..4c2913cbd7 100644 --- a/src/tests/test_wildcard_tree.cpp +++ b/src/tests/test_wildcard_tree.cpp @@ -10,7 +10,7 @@ BOOST_AUTO_TEST_CASE(test_wildcard_tree_single_words) { WildcardTreeNode root(false); - root.insert("test"); + root.add("test"); BOOST_CHECK_EQUAL(root.search("tes").first, WildcardTreeNode::NotFound); BOOST_CHECK_EQUAL(root.search("test").first, WildcardTreeNode::Found); @@ -22,8 +22,8 @@ BOOST_AUTO_TEST_CASE(test_wildcard_tree_ambiguity) { WildcardTreeNode root(false); - root.insert("test"); - root.insert("te"); + root.add("test"); + root.add("te"); BOOST_CHECK_EQUAL(root.search("te").first, WildcardTreeNode::Ambiguous); BOOST_CHECK_EQUAL(root.search("test").first, WildcardTreeNode::Found); @@ -34,7 +34,7 @@ BOOST_AUTO_TEST_CASE(test_wildcard_tree_remove) { WildcardTreeNode root(false); - root.insert("test"); + root.add("test"); BOOST_CHECK_EQUAL(root.search("test").first, WildcardTreeNode::Found); BOOST_CHECK_EQUAL(root.search("test").second, "test"); @@ -48,8 +48,8 @@ BOOST_AUTO_TEST_CASE(test_wildcard_tree_partial_search) { WildcardTreeNode root(false); - root.insert("test"); - root.insert("te"); + root.add("test"); + root.add("te"); BOOST_CHECK_EQUAL(root.search("te").first, WildcardTreeNode::Ambiguous); BOOST_CHECK_EQUAL(root.search("test").first, WildcardTreeNode::Found); @@ -66,8 +66,8 @@ BOOST_AUTO_TEST_CASE(test_wildcard_tree_search_after_remove) { WildcardTreeNode root(false); - root.insert("test"); - root.insert("testing"); + root.add("test"); + root.add("testing"); root.remove("test"); BOOST_CHECK_EQUAL(root.search("test").first, WildcardTreeNode::NotFound); From 836bca6f82f4a1b44cdf3b0f04625621462fa6bd Mon Sep 17 00:00:00 2001 From: ramon-bernardo Date: Thu, 5 Sep 2024 23:22:38 -0300 Subject: [PATCH 08/24] Fix wildcard_tree equals test --- src/tests/test_wildcard_tree.cpp | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/src/tests/test_wildcard_tree.cpp b/src/tests/test_wildcard_tree.cpp index 4c2913cbd7..ea8b8bbd45 100644 --- a/src/tests/test_wildcard_tree.cpp +++ b/src/tests/test_wildcard_tree.cpp @@ -12,10 +12,14 @@ BOOST_AUTO_TEST_CASE(test_wildcard_tree_single_words) root.add("test"); - BOOST_CHECK_EQUAL(root.search("tes").first, WildcardTreeNode::NotFound); + BOOST_CHECK_EQUAL(root.search("tes").first, WildcardTreeNode::Found); + BOOST_CHECK_EQUAL(root.search("tes").second, "test"); + BOOST_CHECK_EQUAL(root.search("test").first, WildcardTreeNode::Found); BOOST_CHECK_EQUAL(root.search("test").second, "test"); + BOOST_CHECK_EQUAL(root.search("testing").first, WildcardTreeNode::NotFound); + BOOST_CHECK_EQUAL(root.search("testing").second, ""); } BOOST_AUTO_TEST_CASE(test_wildcard_tree_ambiguity) @@ -26,6 +30,8 @@ BOOST_AUTO_TEST_CASE(test_wildcard_tree_ambiguity) root.add("te"); BOOST_CHECK_EQUAL(root.search("te").first, WildcardTreeNode::Ambiguous); + BOOST_CHECK_EQUAL(root.search("te").second, ""); + BOOST_CHECK_EQUAL(root.search("test").first, WildcardTreeNode::Found); BOOST_CHECK_EQUAL(root.search("test").second, "test"); } @@ -52,6 +58,8 @@ BOOST_AUTO_TEST_CASE(test_wildcard_tree_partial_search) root.add("te"); BOOST_CHECK_EQUAL(root.search("te").first, WildcardTreeNode::Ambiguous); + BOOST_CHECK_EQUAL(root.search("te").second, ""); + BOOST_CHECK_EQUAL(root.search("test").first, WildcardTreeNode::Found); BOOST_CHECK_EQUAL(root.search("test").second, "test"); @@ -59,7 +67,9 @@ BOOST_AUTO_TEST_CASE(test_wildcard_tree_partial_search) BOOST_CHECK_EQUAL(root.search("te").first, WildcardTreeNode::Found); BOOST_CHECK_EQUAL(root.search("te").second, "te"); + BOOST_CHECK_EQUAL(root.search("test").first, WildcardTreeNode::NotFound); + BOOST_CHECK_EQUAL(root.search("test").second, ""); } BOOST_AUTO_TEST_CASE(test_wildcard_tree_search_after_remove) @@ -71,6 +81,8 @@ BOOST_AUTO_TEST_CASE(test_wildcard_tree_search_after_remove) root.remove("test"); BOOST_CHECK_EQUAL(root.search("test").first, WildcardTreeNode::NotFound); + BOOST_CHECK_EQUAL(root.search("test").second, ""); + BOOST_CHECK_EQUAL(root.search("testing").first, WildcardTreeNode::Found); BOOST_CHECK_EQUAL(root.search("testing").second, "testing"); } From 156dfe63de6e69a99c8613997dc0da4754d2a030 Mon Sep 17 00:00:00 2001 From: ramon-bernardo Date: Thu, 5 Sep 2024 23:47:13 -0300 Subject: [PATCH 09/24] Fix wildcard_tree equals test --- src/tests/test_wildcard_tree.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/tests/test_wildcard_tree.cpp b/src/tests/test_wildcard_tree.cpp index ea8b8bbd45..58b8c6af7f 100644 --- a/src/tests/test_wildcard_tree.cpp +++ b/src/tests/test_wildcard_tree.cpp @@ -77,12 +77,12 @@ BOOST_AUTO_TEST_CASE(test_wildcard_tree_search_after_remove) WildcardTreeNode root(false); root.add("test"); - root.add("testing"); + root.add("te"); root.remove("test"); BOOST_CHECK_EQUAL(root.search("test").first, WildcardTreeNode::NotFound); BOOST_CHECK_EQUAL(root.search("test").second, ""); - BOOST_CHECK_EQUAL(root.search("testing").first, WildcardTreeNode::Found); - BOOST_CHECK_EQUAL(root.search("testing").second, "testing"); + BOOST_CHECK_EQUAL(root.search("te").first, WildcardTreeNode::Found); + BOOST_CHECK_EQUAL(root.search("te").second, "te"); } From de1a843a60ff5cc6f1d9566569fed12e71b8135a Mon Sep 17 00:00:00 2001 From: ramon-bernardo Date: Fri, 6 Sep 2024 19:34:13 -0300 Subject: [PATCH 10/24] Revert fix name test module --- src/tests/test_generate_token.cpp | 2 +- src/tests/test_sha1.cpp | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/tests/test_generate_token.cpp b/src/tests/test_generate_token.cpp index 399fa63090..ff9d97ddf8 100644 --- a/src/tests/test_generate_token.cpp +++ b/src/tests/test_generate_token.cpp @@ -1,4 +1,4 @@ -#define BOOST_TEST_MODULE generate_token +#define BOOST_TEST_MODULE rsa #include "../otpch.h" diff --git a/src/tests/test_sha1.cpp b/src/tests/test_sha1.cpp index 9cffa4b741..dddac776f9 100644 --- a/src/tests/test_sha1.cpp +++ b/src/tests/test_sha1.cpp @@ -1,4 +1,4 @@ -#define BOOST_TEST_MODULE sha1 +#define BOOST_TEST_MODULE rsa #include "../otpch.h" From 9bf2a710f0deadc0c0ebf45a08029b36369827c5 Mon Sep 17 00:00:00 2001 From: ramon-bernardo Date: Sun, 29 Sep 2024 19:12:46 -0300 Subject: [PATCH 11/24] Add wildcard tree doc --- src/wildcardtree.cpp | 62 ++++++++++++++--------------- src/wildcardtree.h | 94 ++++++++++++++++++++++++++++++++++++++++++-- 2 files changed, 121 insertions(+), 35 deletions(-) diff --git a/src/wildcardtree.cpp b/src/wildcardtree.cpp index c29fb2af84..d6023c1d1a 100644 --- a/src/wildcardtree.cpp +++ b/src/wildcardtree.cpp @@ -8,37 +8,6 @@ #include #include -WildcardTreeNode* WildcardTreeNode::find_child(char c) -{ - auto it = children.find(c); - if (it == children.end()) { - return nullptr; - } - return &it->second; -} - -const WildcardTreeNode* WildcardTreeNode::find_child(char c) const -{ - auto it = children.find(c); - if (it == children.end()) { - return nullptr; - } - return &it->second; -} - -WildcardTreeNode* WildcardTreeNode::add_child(char c, bool breakpoint) -{ - if (auto child = find_child(c)) { - if (breakpoint && !child->breakpoint) { - child->breakpoint = true; - } - return child; - } - - auto pair = children.emplace(std::piecewise_construct, std::forward_as_tuple(c), std::forward_as_tuple(breakpoint)); - return &pair.first->second; -} - void WildcardTreeNode::add(const std::string& s) { auto node = this; @@ -111,3 +80,34 @@ std::pair WildcardTreeNode::search( node = &it->second; } while (true); } + +WildcardTreeNode* WildcardTreeNode::find_child(char c) +{ + auto it = children.find(c); + if (it == children.end()) { + return nullptr; + } + return &it->second; +} + +const WildcardTreeNode* WildcardTreeNode::find_child(char c) const +{ + auto it = children.find(c); + if (it == children.end()) { + return nullptr; + } + return &it->second; +} + +WildcardTreeNode* WildcardTreeNode::add_child(char c, bool breakpoint) +{ + if (auto child = find_child(c)) { + if (breakpoint && !child->breakpoint) { + child->breakpoint = true; + } + return child; + } + + auto pair = children.emplace(std::piecewise_construct, std::forward_as_tuple(c), std::forward_as_tuple(breakpoint)); + return &pair.first->second; +} diff --git a/src/wildcardtree.h b/src/wildcardtree.h index c0d704cae3..af782bec1c 100644 --- a/src/wildcardtree.h +++ b/src/wildcardtree.h @@ -6,9 +6,35 @@ #include "enums.h" +/** + * @class WildcardTreeNode + * @brief Represents a node in a wildcard tree. Each node can store children nodes, with + * an optional "breakpoint" to mark the end of a valid string. + */ class WildcardTreeNode { public: + /** + * @brief Constructs a WildcardTreeNode with an optional breakpoint. + * @param {breakpoint} A boolean + * value indicating if the node represents a breakpoint (i.e., the end of a string). + */ + explicit WildcardTreeNode(bool breakpoint) : breakpoint(breakpoint) {} + + /** + * @brief Move constructor for WildcardTreeNode. + * @param other The node to move from. + */ + WildcardTreeNode(WildcardTreeNode&& other) = default; + + /** + * @enum SearchResult + * @brief Represents the result of a search operation in the wildcard tree. + * + * - Found: The exact string or path was found. + * - NotFound: The string or path does not exist in the tree. + * - Ambiguous: The search result is ambiguous (e.g., multiple valid continuations exist). + */ enum SearchResult { Found, @@ -16,24 +42,84 @@ class WildcardTreeNode Ambiguous, }; - explicit WildcardTreeNode(bool breakpoint) : breakpoint(breakpoint) {} - WildcardTreeNode(WildcardTreeNode&& other) = default; - - // non-copyable + /// Deleted copy constructor to ensure WildcardTreeNode is non-copyable. WildcardTreeNode(const WildcardTreeNode&) = delete; + /// Deleted assignment operator to ensure WildcardTreeNode is non-copyable. WildcardTreeNode& operator=(const WildcardTreeNode&) = delete; + /** + * @brief Adds a string to the wildcard tree. + * + * This method breaks the string into characters + * and adds them as children nodes. + * If the string already exists, it updates the final node to represent a + * valid breakpoint. + * + * @param {s} The string to be added. + */ void add(const std::string& s); + + /** + * @brief Removes a string from the wildcard tree. + * + * This method traverses the tree based on + * the input string and marks the final node as non-breakpoint. + * If the node becomes orphaned (no children and + * not a breakpoint), it is removed. + * + * @param {s} The string to be removed. + */ void remove(const std::string& s); + /** + * @brief Searches for a string in the wildcard tree. + * + * This method traverses the tree based on + * the input query string and returns the search result and matched string. + * + * @param {query} The string + * to search for. + * + * @return A pair containing the search result and the matched string. + */ std::pair search(const std::string& query) const; private: + /** + * @brief Finds a child node corresponding to a character. + * @param {c} The character to search for + * among the children. + * @return A pointer to the child node if found, otherwise nullptr. + */ WildcardTreeNode* find_child(char c); + + /** + * @brief Finds a child node corresponding to a character (const version). + * @param {c} The character + * to search for among the children. + * @return A const pointer to the child node if found, otherwise nullptr. + */ const WildcardTreeNode* find_child(char c) const; + + /** + * @brief Adds a child node for a specific character. + * + * If the child node for the character + * already exists, it will be updated. + * If it does not exist, a new node will be created. + * + * + * @param {c} The character to add as a child node. + * @param {breakpoint} A boolean value indicating if this + * node represents a breakpoint. + * @return A pointer to the added or existing child node. + */ WildcardTreeNode* add_child(char c, bool breakpoint); + /// A map of child nodes indexed by characters. std::map children; + + /// Indicates whether this node represents a breakpoint (end of a valid string). bool breakpoint; }; From 0293812c3fa37924a8b61fb77198be0311180c0c Mon Sep 17 00:00:00 2001 From: ramon-bernardo Date: Sun, 29 Sep 2024 19:21:46 -0300 Subject: [PATCH 12/24] Add wildcard tree doc --- src/wildcardtree.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/wildcardtree.h b/src/wildcardtree.h index af782bec1c..cbdeb62393 100644 --- a/src/wildcardtree.h +++ b/src/wildcardtree.h @@ -119,7 +119,7 @@ class WildcardTreeNode /// A map of child nodes indexed by characters. std::map children; - /// Indicates whether this node represents a breakpoint (end of a valid string). + /// Indicates whether this node represents a breakpoint (end of a string). bool breakpoint; }; From 131c96fed5d489b47e4f8199fdc1aa26349c42ff Mon Sep 17 00:00:00 2001 From: ramon-bernardo Date: Sun, 29 Sep 2024 19:23:00 -0300 Subject: [PATCH 13/24] Add wildcard tree doc --- src/wildcardtree.h | 100 ++++++++++++++++++++++----------------------- 1 file changed, 50 insertions(+), 50 deletions(-) diff --git a/src/wildcardtree.h b/src/wildcardtree.h index cbdeb62393..ff35d9e58a 100644 --- a/src/wildcardtree.h +++ b/src/wildcardtree.h @@ -9,32 +9,32 @@ /** * @class WildcardTreeNode * @brief Represents a node in a wildcard tree. Each node can store children nodes, with - * an optional "breakpoint" to mark the end of a valid string. + * an optional "breakpoint" to mark the end of a string. */ class WildcardTreeNode { public: /** - * @brief Constructs a WildcardTreeNode with an optional breakpoint. - * @param {breakpoint} A boolean + * @brief Constructs a WildcardTreeNode with an optional breakpoint. + * @param {breakpoint} A boolean * value indicating if the node represents a breakpoint (i.e., the end of a string). - */ + */ explicit WildcardTreeNode(bool breakpoint) : breakpoint(breakpoint) {} /** - * @brief Move constructor for WildcardTreeNode. - * @param other The node to move from. - */ + * @brief Move constructor for WildcardTreeNode. + * @param other The node to move from. + */ WildcardTreeNode(WildcardTreeNode&& other) = default; /** - * @enum SearchResult - * @brief Represents the result of a search operation in the wildcard tree. - * + * @enum SearchResult + * @brief Represents the result of a search operation in the wildcard tree. + * * - Found: The exact string or path was found. - * - NotFound: The string or path does not exist in the tree. + * - NotFound: The string or path does not exist in the tree. * - Ambiguous: The search result is ambiguous (e.g., multiple valid continuations exist). - */ + */ enum SearchResult { Found, @@ -48,72 +48,72 @@ class WildcardTreeNode WildcardTreeNode& operator=(const WildcardTreeNode&) = delete; /** - * @brief Adds a string to the wildcard tree. - * - * This method breaks the string into characters + * @brief Adds a string to the wildcard tree. + * + * This method breaks the string into characters * and adds them as children nodes. - * If the string already exists, it updates the final node to represent a - * valid breakpoint. - * - * @param {s} The string to be added. - */ + * If the string already exists, it updates the final node to represent a + * breakpoint. + * + * @param {s} The string to be added. + */ void add(const std::string& s); /** - * @brief Removes a string from the wildcard tree. - * - * This method traverses the tree based on + * @brief Removes a string from the wildcard tree. + * + * This method traverses the tree based on * the input string and marks the final node as non-breakpoint. - * If the node becomes orphaned (no children and + * If the node becomes orphaned (no children and * not a breakpoint), it is removed. - * - * @param {s} The string to be removed. - */ + * + * @param {s} The string to be removed. + */ void remove(const std::string& s); /** - * @brief Searches for a string in the wildcard tree. - * - * This method traverses the tree based on + * @brief Searches for a string in the wildcard tree. + * + * This method traverses the tree based on * the input query string and returns the search result and matched string. - * - * @param {query} The string + * + * @param {query} The string * to search for. - * + * * @return A pair containing the search result and the matched string. - */ + */ std::pair search(const std::string& query) const; private: /** - * @brief Finds a child node corresponding to a character. - * @param {c} The character to search for + * @brief Finds a child node corresponding to a character. + * @param {c} The character to search for * among the children. - * @return A pointer to the child node if found, otherwise nullptr. - */ + * @return A pointer to the child node if found, otherwise nullptr. + */ WildcardTreeNode* find_child(char c); /** - * @brief Finds a child node corresponding to a character (const version). - * @param {c} The character + * @brief Finds a child node corresponding to a character (const version). + * @param {c} The character * to search for among the children. - * @return A const pointer to the child node if found, otherwise nullptr. + * @return A const pointer to the child node if found, otherwise nullptr. */ const WildcardTreeNode* find_child(char c) const; /** - * @brief Adds a child node for a specific character. - * - * If the child node for the character + * @brief Adds a child node for a specific character. + * + * If the child node for the character * already exists, it will be updated. - * If it does not exist, a new node will be created. - * - * + * If it does not exist, a new node will be created. + * + * * @param {c} The character to add as a child node. - * @param {breakpoint} A boolean value indicating if this + * @param {breakpoint} A boolean value indicating if this * node represents a breakpoint. - * @return A pointer to the added or existing child node. - */ + * @return A pointer to the added or existing child node. + */ WildcardTreeNode* add_child(char c, bool breakpoint); /// A map of child nodes indexed by characters. From d409625aa570447f1005c78980566f848b83a686 Mon Sep 17 00:00:00 2001 From: ramon-bernardo Date: Sun, 29 Sep 2024 19:26:50 -0300 Subject: [PATCH 14/24] Add wildcard tree doc --- src/wildcardtree.h | 38 +++++++++++++++----------------------- 1 file changed, 15 insertions(+), 23 deletions(-) diff --git a/src/wildcardtree.h b/src/wildcardtree.h index ff35d9e58a..27d67039d3 100644 --- a/src/wildcardtree.h +++ b/src/wildcardtree.h @@ -16,6 +16,7 @@ class WildcardTreeNode public: /** * @brief Constructs a WildcardTreeNode with an optional breakpoint. + * * @param {breakpoint} A boolean * value indicating if the node represents a breakpoint (i.e., the end of a string). */ @@ -23,6 +24,7 @@ class WildcardTreeNode /** * @brief Move constructor for WildcardTreeNode. + * * @param other The node to move from. */ WildcardTreeNode(WildcardTreeNode&& other) = default; @@ -50,10 +52,8 @@ class WildcardTreeNode /** * @brief Adds a string to the wildcard tree. * - * This method breaks the string into characters - * and adds them as children nodes. - * If the string already exists, it updates the final node to represent a - * breakpoint. + * This method breaks the string into characters and adds them as children nodes. + * If the string already exists, it updates the final node to represent a breakpoint. * * @param {s} The string to be added. */ @@ -62,10 +62,8 @@ class WildcardTreeNode /** * @brief Removes a string from the wildcard tree. * - * This method traverses the tree based on - * the input string and marks the final node as non-breakpoint. - * If the node becomes orphaned (no children and - * not a breakpoint), it is removed. + * This method traverses the tree based on the input string and marks the final node as non-breakpoint. + * If the node becomes orphaned (no children and not a breakpoint), it is removed. * * @param {s} The string to be removed. */ @@ -74,12 +72,9 @@ class WildcardTreeNode /** * @brief Searches for a string in the wildcard tree. * - * This method traverses the tree based on - * the input query string and returns the search result and matched string. - * - * @param {query} The string - * to search for. + * This method traverses the tree based on the input query string and returns the search result and matched string. * + * @param {query} The string to search for. * @return A pair containing the search result and the matched string. */ std::pair search(const std::string& query) const; @@ -87,16 +82,16 @@ class WildcardTreeNode private: /** * @brief Finds a child node corresponding to a character. - * @param {c} The character to search for - * among the children. + * + * @param {c} The character to search for among the children. * @return A pointer to the child node if found, otherwise nullptr. */ WildcardTreeNode* find_child(char c); /** * @brief Finds a child node corresponding to a character (const version). - * @param {c} The character - * to search for among the children. + * + * @param {c} The character to search for among the children. * @return A const pointer to the child node if found, otherwise nullptr. */ const WildcardTreeNode* find_child(char c) const; @@ -104,14 +99,11 @@ class WildcardTreeNode /** * @brief Adds a child node for a specific character. * - * If the child node for the character - * already exists, it will be updated. - * If it does not exist, a new node will be created. - * + * If the child node for the character already exists, it will be updated. If it does not exist, a new node will be + * created. * * @param {c} The character to add as a child node. - * @param {breakpoint} A boolean value indicating if this - * node represents a breakpoint. + * @param {breakpoint} A boolean value indicating if this node represents a breakpoint. * @return A pointer to the added or existing child node. */ WildcardTreeNode* add_child(char c, bool breakpoint); From 4d9d33587f7dc65d3ef4bd80c330973c0db8251e Mon Sep 17 00:00:00 2001 From: ramon-bernardo Date: Sun, 29 Sep 2024 19:28:30 -0300 Subject: [PATCH 15/24] Add wildcard tree doc --- src/wildcardtree.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/wildcardtree.h b/src/wildcardtree.h index 27d67039d3..2ac2589ff9 100644 --- a/src/wildcardtree.h +++ b/src/wildcardtree.h @@ -25,7 +25,7 @@ class WildcardTreeNode /** * @brief Move constructor for WildcardTreeNode. * - * @param other The node to move from. + * @param {other} The node to move from. */ WildcardTreeNode(WildcardTreeNode&& other) = default; From dff97d6d5718e183b8642c02aa2abfa0f630a7f2 Mon Sep 17 00:00:00 2001 From: ramon-bernardo Date: Thu, 3 Oct 2024 19:16:57 -0300 Subject: [PATCH 16/24] Use std::shared_ptr instead raw pointers --- src/wildcardtree.cpp | 24 ++++++++++++------------ src/wildcardtree.h | 12 +++++++----- 2 files changed, 19 insertions(+), 17 deletions(-) diff --git a/src/wildcardtree.cpp b/src/wildcardtree.cpp index d6023c1d1a..075a6b191f 100644 --- a/src/wildcardtree.cpp +++ b/src/wildcardtree.cpp @@ -10,7 +10,7 @@ void WildcardTreeNode::add(const std::string& s) { - auto node = this; + auto node = shared_from_this(); auto length = s.length() - 1; for (size_t pos = 0; pos < length; ++pos) { @@ -21,9 +21,9 @@ void WildcardTreeNode::add(const std::string& s) void WildcardTreeNode::remove(const std::string& s) { - auto node = this; + auto node = shared_from_this(); - std::stack path; + std::stack> path; path.push(node); auto len = s.length(); @@ -56,7 +56,7 @@ void WildcardTreeNode::remove(const std::string& s) std::pair WildcardTreeNode::search(const std::string& query) const { - auto node = this; + auto node = shared_from_this(); for (auto c : query) { node = node->find_child(c); @@ -77,29 +77,29 @@ std::pair WildcardTreeNode::search( auto it = node->children.begin(); result += it->first; - node = &it->second; + node = it->second; } while (true); } -WildcardTreeNode* WildcardTreeNode::find_child(char c) +std::shared_ptr WildcardTreeNode::find_child(char c) { auto it = children.find(c); if (it == children.end()) { return nullptr; } - return &it->second; + return it->second; } -const WildcardTreeNode* WildcardTreeNode::find_child(char c) const +std::shared_ptr WildcardTreeNode::find_child(char c) const { auto it = children.find(c); if (it == children.end()) { return nullptr; } - return &it->second; + return it->second; } -WildcardTreeNode* WildcardTreeNode::add_child(char c, bool breakpoint) +std::shared_ptr WildcardTreeNode::add_child(char c, bool breakpoint) { if (auto child = find_child(c)) { if (breakpoint && !child->breakpoint) { @@ -108,6 +108,6 @@ WildcardTreeNode* WildcardTreeNode::add_child(char c, bool breakpoint) return child; } - auto pair = children.emplace(std::piecewise_construct, std::forward_as_tuple(c), std::forward_as_tuple(breakpoint)); - return &pair.first->second; + auto pair = children.emplace(c, std::make_shared(breakpoint)); + return pair.first->second; } diff --git a/src/wildcardtree.h b/src/wildcardtree.h index 2ac2589ff9..716dab6fb4 100644 --- a/src/wildcardtree.h +++ b/src/wildcardtree.h @@ -6,12 +6,14 @@ #include "enums.h" +#include + /** * @class WildcardTreeNode * @brief Represents a node in a wildcard tree. Each node can store children nodes, with * an optional "breakpoint" to mark the end of a string. */ -class WildcardTreeNode +class WildcardTreeNode final : public std::enable_shared_from_this { public: /** @@ -86,7 +88,7 @@ class WildcardTreeNode * @param {c} The character to search for among the children. * @return A pointer to the child node if found, otherwise nullptr. */ - WildcardTreeNode* find_child(char c); + std::shared_ptr find_child(char c); /** * @brief Finds a child node corresponding to a character (const version). @@ -94,7 +96,7 @@ class WildcardTreeNode * @param {c} The character to search for among the children. * @return A const pointer to the child node if found, otherwise nullptr. */ - const WildcardTreeNode* find_child(char c) const; + std::shared_ptr find_child(char c) const; /** * @brief Adds a child node for a specific character. @@ -106,10 +108,10 @@ class WildcardTreeNode * @param {breakpoint} A boolean value indicating if this node represents a breakpoint. * @return A pointer to the added or existing child node. */ - WildcardTreeNode* add_child(char c, bool breakpoint); + std::shared_ptr add_child(char c, bool breakpoint); /// A map of child nodes indexed by characters. - std::map children; + std::map> children; /// Indicates whether this node represents a breakpoint (end of a string). bool breakpoint; From 422df1c896f9b16d332c43a9ae6f92db3da54216 Mon Sep 17 00:00:00 2001 From: ramon-bernardo Date: Thu, 3 Oct 2024 19:20:22 -0300 Subject: [PATCH 17/24] Update wildcard doc --- src/wildcardtree.h | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) diff --git a/src/wildcardtree.h b/src/wildcardtree.h index 716dab6fb4..03db11b239 100644 --- a/src/wildcardtree.h +++ b/src/wildcardtree.h @@ -10,8 +10,8 @@ /** * @class WildcardTreeNode - * @brief Represents a node in a wildcard tree. Each node can store children nodes, with - * an optional "breakpoint" to mark the end of a string. + * @brief Represents a node in a wildcard tree. Each node stores child nodes using `std::shared_ptr`, + * and optionally marks a "breakpoint" to represent the end of a string. */ class WildcardTreeNode final : public std::enable_shared_from_this { @@ -19,8 +19,7 @@ class WildcardTreeNode final : public std::enable_shared_from_this find_child(char c); @@ -94,7 +93,7 @@ class WildcardTreeNode final : public std::enable_shared_from_this find_child(char c) const; @@ -106,7 +105,7 @@ class WildcardTreeNode final : public std::enable_shared_from_this add_child(char c, bool breakpoint); From aaac8d9b4ab5d4cc6a9cecbcd27d7938f1d531ba Mon Sep 17 00:00:00 2001 From: ramon-bernardo Date: Mon, 7 Oct 2024 19:46:38 -0300 Subject: [PATCH 18/24] Wildcardtree code improv. --- src/game.cpp | 16 ++--- src/game.h | 2 - src/wildcardtree.cpp | 138 ++++++++++++++++++++++++++----------------- src/wildcardtree.h | 114 ++++++++++++++++++----------------- 4 files changed, 152 insertions(+), 118 deletions(-) diff --git a/src/game.cpp b/src/game.cpp index 84dda56ce7..a49da36be3 100644 --- a/src/game.cpp +++ b/src/game.cpp @@ -464,14 +464,14 @@ ReturnValue Game::getPlayerByNameWildcard(const std::string& s, Player*& player) if (s.back() == '~') { const auto& query = boost::algorithm::to_lower_copy(s.substr(0, strlen - 1)); - auto searchResult = wildcardTree.search(query); - switch (searchResult.first) { - case WildcardTreeNode::NotFound: + auto search_result = tfs::game::wildcardtree::search(query); + switch (search_result.first) { + case WildcardTreeSearchResult::NotFound: return RETURNVALUE_PLAYERWITHTHISNAMEISNOTONLINE; - case WildcardTreeNode::Ambiguous: + case WildcardTreeSearchResult::Ambiguous: return RETURNVALUE_NAMEISTOOAMBIGUOUS; - case WildcardTreeNode::Found: - player = getPlayerByName(searchResult.second); + case WildcardTreeSearchResult::Found: + player = getPlayerByName(search_result.second); break; } } else { @@ -5668,7 +5668,7 @@ void Game::addPlayer(Player* player) const std::string& lowercase_name = boost::algorithm::to_lower_copy(player->getName()); mappedPlayerNames[lowercase_name] = player; mappedPlayerGuids[player->getGUID()] = player; - wildcardTree.add(lowercase_name); + tfs::game::wildcardtree::add(lowercase_name); players[player->getID()] = player; } @@ -5677,7 +5677,7 @@ void Game::removePlayer(Player* player) const std::string& lowercase_name = boost::algorithm::to_lower_copy(player->getName()); mappedPlayerNames.erase(lowercase_name); mappedPlayerGuids.erase(player->getGUID()); - wildcardTree.remove(lowercase_name); + tfs::game::wildcardtree::remove(lowercase_name); players.erase(player->getID()); } diff --git a/src/game.h b/src/game.h index 25cc3df568..716d8faa64 100644 --- a/src/game.h +++ b/src/game.h @@ -519,8 +519,6 @@ class Game size_t lastBucket = 0; - WildcardTreeNode wildcardTree{false}; - std::map npcs; std::map monsters; diff --git a/src/wildcardtree.cpp b/src/wildcardtree.cpp index 075a6b191f..c64b588807 100644 --- a/src/wildcardtree.cpp +++ b/src/wildcardtree.cpp @@ -8,26 +8,73 @@ #include #include -void WildcardTreeNode::add(const std::string& s) +namespace { + +auto wildcardtree_root = new WildcardTreeNode(false); + +const WildcardTreeNode* WildcardTreeNode::find_child(char c) const { - auto node = shared_from_this(); + auto it = children.find(c); + if (it == children.end()) { + return nullptr; + } + return it->second; +} - auto length = s.length() - 1; - for (size_t pos = 0; pos < length; ++pos) { +WildcardTreeNode* WildcardTreeNode::find_child(char c) +{ + auto it = children.find(c); + if (it == children.end()) { + return nullptr; + } + return it->second; +} + +WildcardTreeNode* WildcardTreeNode::add_child(char c, bool breakpoint) +{ + if (auto child = find_child(c)) { + // If the child already exists, update its breakpoint if necessary + if (breakpoint && !child->breakpoint) { + child->breakpoint = true; + } + return child; + } + + auto node = new WildcardTreeNode(breakpoint); + auto pair = children.emplace(c, node); + return node; +} + +} // namespace + +namespace tfs::game::wildcardtree { + +void add(std::string_view s) +{ + auto node = wildcardtree_root; + + auto length = s.length(); + // Iterate through the string, adding nodes for each character except the last + for (size_t pos = 0; pos < length - 1; ++pos) { + // Add child nodes without marking breakpoints node = node->add_child(s[pos], false); } - node->add_child(s[length], true); + + // Mark the final character as a breakpoint + node->add_child(s.back(), true); } -void WildcardTreeNode::remove(const std::string& s) +void remove(std::string_view s) { - auto node = shared_from_this(); + auto node = wildcardtree_root; - std::stack> path; + // Stack to keep track of the path as we traverse the tree + std::stack path; path.push(node); - auto len = s.length(); - for (size_t pos = 0; pos < len; ++pos) { + auto length = s.length(); + // Traverse the tree based on the input string + for (size_t pos = 0; pos < length; ++pos) { node = node->find_child(s[pos]); if (!node) { return; @@ -37,77 +84,60 @@ void WildcardTreeNode::remove(const std::string& s) node->breakpoint = false; - do { + // Remove orphaned nodes + while (true) { node = path.top(); path.pop(); + if (path.empty()) { + // Stop if the root is reached + break; + } - if (!node->children.empty() || node->breakpoint || path.empty()) { + if (node->breakpoint || !node->children.empty()) { + // Stop if the node has children or is a breakpoint break; } - node = path.top(); + node = path.top(); // Go back to the parent node - auto it = node->children.find(s[--len]); + auto it = node->children.find(s[--length]); if (it != node->children.end()) { + // Erase the child node from the parent if it exists node->children.erase(it); } - } while (true); + } } -std::pair WildcardTreeNode::search(const std::string& query) const +std::pair search(std::string_view query) { - auto node = shared_from_this(); + auto node = wildcardtree_root; for (auto c : query) { node = node->find_child(c); if (!node) { - return std::make_pair(NotFound, ""); + return std::make_pair(WildcardTreeSearchResult::NotFound, ""); } } - auto result = query; + std::string result(query); - do { - auto size = node->children.size(); + // Continue traversal until ambiguity or the end of the string is found + while (true) { + const auto size = node->children.size(); if (size == 0) { - return std::make_pair(Found, result); - } else if (size > 1 || node->breakpoint) { - return std::make_pair(Ambiguous, ""); + // Exact match found + return std::make_pair(WildcardTreeSearchResult::Found, result); + } + + if (size > 1 || node->breakpoint) { + // Return ambiguous if multiple child nodes exist or a breakpoint is reached + return std::make_pair(WildcardTreeSearchResult::Ambiguous, ""); } auto it = node->children.begin(); result += it->first; node = it->second; - } while (true); -} - -std::shared_ptr WildcardTreeNode::find_child(char c) -{ - auto it = children.find(c); - if (it == children.end()) { - return nullptr; } - return it->second; } -std::shared_ptr WildcardTreeNode::find_child(char c) const -{ - auto it = children.find(c); - if (it == children.end()) { - return nullptr; - } - return it->second; -} - -std::shared_ptr WildcardTreeNode::add_child(char c, bool breakpoint) -{ - if (auto child = find_child(c)) { - if (breakpoint && !child->breakpoint) { - child->breakpoint = true; - } - return child; - } - - auto pair = children.emplace(c, std::make_shared(breakpoint)); - return pair.first->second; -} +} // namespace tfs::game::wildcardtree diff --git a/src/wildcardtree.h b/src/wildcardtree.h index 03db11b239..3ae76fd577 100644 --- a/src/wildcardtree.h +++ b/src/wildcardtree.h @@ -1,4 +1,5 @@ // Copyright 2023 The Forgotten Server Authors. All rights reserved. +// Copyright 2023 The Forgotten Server Authors. All rights reserved. // Use of this source code is governed by the GPL-2.0 License that can be found in the LICENSE file. #ifndef FS_WILDCARDTREE_H @@ -6,14 +7,14 @@ #include "enums.h" -#include +namespace { /** * @class WildcardTreeNode * @brief Represents a node in a wildcard tree. Each node stores child nodes using `std::shared_ptr`, * and optionally marks a "breakpoint" to represent the end of a string. */ -class WildcardTreeNode final : public std::enable_shared_from_this +class WildcardTreeNode final { public: /** @@ -30,72 +31,26 @@ class WildcardTreeNode final : public std::enable_shared_from_this search(const std::string& query) const; - -private: - /** - * @brief Finds a child node corresponding to a character. + * @brief Finds a child node corresponding to a character (const version). * * @param {c} The character to search for among the children. * @return A shared pointer to the child node if found, otherwise nullptr. */ - std::shared_ptr find_child(char c); + const WildcardTreeNode* find_child(char c) const; /** - * @brief Finds a child node corresponding to a character (const version). + * @brief Finds a child node corresponding to a character. * * @param {c} The character to search for among the children. * @return A shared pointer to the child node if found, otherwise nullptr. */ - std::shared_ptr find_child(char c) const; + WildcardTreeNode* find_child(char c); /** * @brief Adds a child node for a specific character. @@ -107,13 +62,64 @@ class WildcardTreeNode final : public std::enable_shared_from_this add_child(char c, bool breakpoint); + WildcardTreeNode* add_child(char c, bool breakpoint); /// A map of child nodes indexed by characters. - std::map> children; + std::map children; /// Indicates whether this node represents a breakpoint (end of a string). bool breakpoint; }; +} // namespace + +/** + * @enum SearchResult + * @brief Represents the result of a search operation in the wildcard tree. + * + * - Found: The exact string or path was found. + * - NotFound: The string or path does not exist in the tree. + * - Ambiguous: The search result is ambiguous (e.g., multiple valid continuations exist). + */ +enum WildcardTreeSearchResult +{ + Found, + NotFound, + Ambiguous, +}; + +namespace tfs::game::wildcardtree { + +/** + * @brief Adds a string to the wildcard tree. + * + * This method splits the string into characters and adds them as child nodes. + * If the string already exists, it marks the final node as a breakpoint. + * + * @param {s} The string to be added. + */ +void add(std::string_view s); + +/** + * @brief Removes a string from the wildcard tree. + * + * This method traverses the tree based on the input string and marks the final node as non-breakpoint. + * If the node becomes orphaned (no children and not a breakpoint), it is removed. + * + * @param {s} The string to be removed. + */ +void remove(std::string_view s); + +/** + * @brief Searches for a string in the wildcard tree. + * + * This method traverses the tree based on the input query string and returns the search result and matched string. + * + * @param {query} The string to search for. + * @return A pair containing the search result and the matched string. + */ +std::pair search(std::string_view query); + +} // namespace tfs::game::wildcardtree + #endif // FS_WILDCARDTREE_H From 0fc7a18006d6341cd70a2a6665cd5562706514d5 Mon Sep 17 00:00:00 2001 From: ramon-bernardo Date: Mon, 7 Oct 2024 20:06:34 -0300 Subject: [PATCH 19/24] Use std::shared_ptr --- src/wildcardtree.cpp | 20 +++++--------------- src/wildcardtree.h | 16 ++++------------ 2 files changed, 9 insertions(+), 27 deletions(-) diff --git a/src/wildcardtree.cpp b/src/wildcardtree.cpp index c64b588807..20ad99817b 100644 --- a/src/wildcardtree.cpp +++ b/src/wildcardtree.cpp @@ -6,13 +6,12 @@ #include "wildcardtree.h" #include -#include namespace { -auto wildcardtree_root = new WildcardTreeNode(false); +auto wildcardtree_root = std::make_shared(false); -const WildcardTreeNode* WildcardTreeNode::find_child(char c) const +std::shared_ptr WildcardTreeNode::find_child(char c) { auto it = children.find(c); if (it == children.end()) { @@ -21,16 +20,7 @@ const WildcardTreeNode* WildcardTreeNode::find_child(char c) const return it->second; } -WildcardTreeNode* WildcardTreeNode::find_child(char c) -{ - auto it = children.find(c); - if (it == children.end()) { - return nullptr; - } - return it->second; -} - -WildcardTreeNode* WildcardTreeNode::add_child(char c, bool breakpoint) +std::shared_ptr WildcardTreeNode::add_child(char c, bool breakpoint) { if (auto child = find_child(c)) { // If the child already exists, update its breakpoint if necessary @@ -40,7 +30,7 @@ WildcardTreeNode* WildcardTreeNode::add_child(char c, bool breakpoint) return child; } - auto node = new WildcardTreeNode(breakpoint); + auto node = std::make_shared(breakpoint); auto pair = children.emplace(c, node); return node; } @@ -69,7 +59,7 @@ void remove(std::string_view s) auto node = wildcardtree_root; // Stack to keep track of the path as we traverse the tree - std::stack path; + std::stack> path; path.push(node); auto length = s.length(); diff --git a/src/wildcardtree.h b/src/wildcardtree.h index 3ae76fd577..1639463e91 100644 --- a/src/wildcardtree.h +++ b/src/wildcardtree.h @@ -14,7 +14,7 @@ namespace { * @brief Represents a node in a wildcard tree. Each node stores child nodes using `std::shared_ptr`, * and optionally marks a "breakpoint" to represent the end of a string. */ -class WildcardTreeNode final +class WildcardTreeNode final : public std::enable_shared_from_this { public: /** @@ -36,21 +36,13 @@ class WildcardTreeNode final /// Deleted assignment operator to ensure WildcardTreeNode is non-copyable. WildcardTreeNode& operator=(const WildcardTreeNode&) = delete; - /** - * @brief Finds a child node corresponding to a character (const version). - * - * @param {c} The character to search for among the children. - * @return A shared pointer to the child node if found, otherwise nullptr. - */ - const WildcardTreeNode* find_child(char c) const; - /** * @brief Finds a child node corresponding to a character. * * @param {c} The character to search for among the children. * @return A shared pointer to the child node if found, otherwise nullptr. */ - WildcardTreeNode* find_child(char c); + std::shared_ptr find_child(char c); /** * @brief Adds a child node for a specific character. @@ -62,10 +54,10 @@ class WildcardTreeNode final * @param {breakpoint} A boolean value indicating if this node represents a breakpoint. * @return A shared pointer to the added or existing child node. */ - WildcardTreeNode* add_child(char c, bool breakpoint); + std::shared_ptr add_child(char c, bool breakpoint); /// A map of child nodes indexed by characters. - std::map children; + std::map> children; /// Indicates whether this node represents a breakpoint (end of a string). bool breakpoint; From e2191770c3c398541143d8209cf43369161bf053 Mon Sep 17 00:00:00 2001 From: ramon-bernardo Date: Mon, 7 Oct 2024 20:07:56 -0300 Subject: [PATCH 20/24] Remove duplicated header --- src/wildcardtree.h | 1 - 1 file changed, 1 deletion(-) diff --git a/src/wildcardtree.h b/src/wildcardtree.h index 1639463e91..bfcd954200 100644 --- a/src/wildcardtree.h +++ b/src/wildcardtree.h @@ -1,5 +1,4 @@ // Copyright 2023 The Forgotten Server Authors. All rights reserved. -// Copyright 2023 The Forgotten Server Authors. All rights reserved. // Use of this source code is governed by the GPL-2.0 License that can be found in the LICENSE file. #ifndef FS_WILDCARDTREE_H From 4bdbde9be1722016b3d29147f0b943035ceef6e0 Mon Sep 17 00:00:00 2001 From: ramon-bernardo Date: Mon, 7 Oct 2024 20:13:23 -0300 Subject: [PATCH 21/24] Add utility include --- src/wildcardtree.h | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/wildcardtree.h b/src/wildcardtree.h index bfcd954200..9c80b239b2 100644 --- a/src/wildcardtree.h +++ b/src/wildcardtree.h @@ -6,6 +6,8 @@ #include "enums.h" +#include + namespace { /** From 1537efc4d399b619cc60247ed9a1e042d295ef52 Mon Sep 17 00:00:00 2001 From: ramon-bernardo Date: Mon, 7 Oct 2024 20:20:29 -0300 Subject: [PATCH 22/24] Fix emplace map --- src/wildcardtree.cpp | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/wildcardtree.cpp b/src/wildcardtree.cpp index 20ad99817b..39a7e66f04 100644 --- a/src/wildcardtree.cpp +++ b/src/wildcardtree.cpp @@ -30,9 +30,8 @@ std::shared_ptr WildcardTreeNode::add_child(char c, bool break return child; } - auto node = std::make_shared(breakpoint); - auto pair = children.emplace(c, node); - return node; + auto pair = children.emplace(c, std::make_shared(breakpoint)); + return pair.first->second; } } // namespace From 4d4f8d497513bd7b6ad035d21541039a3fee3fe5 Mon Sep 17 00:00:00 2001 From: ramon-bernardo Date: Mon, 7 Oct 2024 20:26:27 -0300 Subject: [PATCH 23/24] Fix wildcardtree namespace in tests --- src/tests/test_wildcard_tree.cpp | 82 ++++++++++++++------------------ 1 file changed, 36 insertions(+), 46 deletions(-) diff --git a/src/tests/test_wildcard_tree.cpp b/src/tests/test_wildcard_tree.cpp index 58b8c6af7f..d858d59c59 100644 --- a/src/tests/test_wildcard_tree.cpp +++ b/src/tests/test_wildcard_tree.cpp @@ -8,81 +8,71 @@ BOOST_AUTO_TEST_CASE(test_wildcard_tree_single_words) { - WildcardTreeNode root(false); + tfs::game::wildcardtree::add("test"); - root.add("test"); + BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("tes").first, WildcardTreeNode::Found); + BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("tes").second, "test"); - BOOST_CHECK_EQUAL(root.search("tes").first, WildcardTreeNode::Found); - BOOST_CHECK_EQUAL(root.search("tes").second, "test"); + BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("test").first, WildcardTreeNode::Found); + BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("test").second, "test"); - BOOST_CHECK_EQUAL(root.search("test").first, WildcardTreeNode::Found); - BOOST_CHECK_EQUAL(root.search("test").second, "test"); - - BOOST_CHECK_EQUAL(root.search("testing").first, WildcardTreeNode::NotFound); - BOOST_CHECK_EQUAL(root.search("testing").second, ""); + BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("testing").first, WildcardTreeNode::NotFound); + BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("testing").second, ""); } BOOST_AUTO_TEST_CASE(test_wildcard_tree_ambiguity) { - WildcardTreeNode root(false); - - root.add("test"); - root.add("te"); + tfs::game::wildcardtree::add("test"); + tfs::game::wildcardtree::add("te"); - BOOST_CHECK_EQUAL(root.search("te").first, WildcardTreeNode::Ambiguous); - BOOST_CHECK_EQUAL(root.search("te").second, ""); + BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("te").first, WildcardTreeNode::Ambiguous); + BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("te").second, ""); - BOOST_CHECK_EQUAL(root.search("test").first, WildcardTreeNode::Found); - BOOST_CHECK_EQUAL(root.search("test").second, "test"); + BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("test").first, WildcardTreeNode::Found); + BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("test").second, "test"); } BOOST_AUTO_TEST_CASE(test_wildcard_tree_remove) { - WildcardTreeNode root(false); - - root.add("test"); + tfs::game::wildcardtree::add("test"); - BOOST_CHECK_EQUAL(root.search("test").first, WildcardTreeNode::Found); - BOOST_CHECK_EQUAL(root.search("test").second, "test"); + BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("test").first, WildcardTreeNode::Found); + BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("test").second, "test"); - root.remove("test"); + tfs::game::wildcardtree::remove("test"); - BOOST_CHECK_EQUAL(root.search("test").first, WildcardTreeNode::NotFound); + BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("test").first, WildcardTreeNode::NotFound); } BOOST_AUTO_TEST_CASE(test_wildcard_tree_partial_search) { - WildcardTreeNode root(false); + tfs::game::wildcardtree::add("test"); + tfs::game::wildcardtree::add("te"); - root.add("test"); - root.add("te"); + BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("te").first, WildcardTreeNode::Ambiguous); + BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("te").second, ""); - BOOST_CHECK_EQUAL(root.search("te").first, WildcardTreeNode::Ambiguous); - BOOST_CHECK_EQUAL(root.search("te").second, ""); + BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("test").first, WildcardTreeNode::Found); + BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("test").second, "test"); - BOOST_CHECK_EQUAL(root.search("test").first, WildcardTreeNode::Found); - BOOST_CHECK_EQUAL(root.search("test").second, "test"); + tfs::game::wildcardtree::remove("test"); - root.remove("test"); + BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("te").first, WildcardTreeNode::Found); + BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("te").second, "te"); - BOOST_CHECK_EQUAL(root.search("te").first, WildcardTreeNode::Found); - BOOST_CHECK_EQUAL(root.search("te").second, "te"); - - BOOST_CHECK_EQUAL(root.search("test").first, WildcardTreeNode::NotFound); - BOOST_CHECK_EQUAL(root.search("test").second, ""); + BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("test").first, WildcardTreeNode::NotFound); + BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("test").second, ""); } BOOST_AUTO_TEST_CASE(test_wildcard_tree_search_after_remove) { - WildcardTreeNode root(false); - - root.add("test"); - root.add("te"); - root.remove("test"); + tfs::game::wildcardtree::add("test"); + tfs::game::wildcardtree::add("te"); + tfs::game::wildcardtree::remove("test"); - BOOST_CHECK_EQUAL(root.search("test").first, WildcardTreeNode::NotFound); - BOOST_CHECK_EQUAL(root.search("test").second, ""); + BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("test").first, WildcardTreeNode::NotFound); + BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("test").second, ""); - BOOST_CHECK_EQUAL(root.search("te").first, WildcardTreeNode::Found); - BOOST_CHECK_EQUAL(root.search("te").second, "te"); + BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("te").first, WildcardTreeNode::Found); + BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("te").second, "te"); } From 4c511c06c7971bbcc18c48564eca78252b3bceb9 Mon Sep 17 00:00:00 2001 From: ramon-bernardo Date: Mon, 7 Oct 2024 20:30:06 -0300 Subject: [PATCH 24/24] Fix wildcardtree enum in tests --- src/tests/test_wildcard_tree.cpp | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/src/tests/test_wildcard_tree.cpp b/src/tests/test_wildcard_tree.cpp index d858d59c59..adace660d5 100644 --- a/src/tests/test_wildcard_tree.cpp +++ b/src/tests/test_wildcard_tree.cpp @@ -10,13 +10,13 @@ BOOST_AUTO_TEST_CASE(test_wildcard_tree_single_words) { tfs::game::wildcardtree::add("test"); - BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("tes").first, WildcardTreeNode::Found); + BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("tes").first, WildcardTreeSearchResult::Found); BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("tes").second, "test"); - BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("test").first, WildcardTreeNode::Found); + BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("test").first, WildcardTreeSearchResult::Found); BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("test").second, "test"); - BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("testing").first, WildcardTreeNode::NotFound); + BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("testing").first, WildcardTreeSearchResult::NotFound); BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("testing").second, ""); } @@ -25,10 +25,10 @@ BOOST_AUTO_TEST_CASE(test_wildcard_tree_ambiguity) tfs::game::wildcardtree::add("test"); tfs::game::wildcardtree::add("te"); - BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("te").first, WildcardTreeNode::Ambiguous); + BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("te").first, WildcardTreeSearchResult::Ambiguous); BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("te").second, ""); - BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("test").first, WildcardTreeNode::Found); + BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("test").first, WildcardTreeSearchResult::Found); BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("test").second, "test"); } @@ -36,12 +36,12 @@ BOOST_AUTO_TEST_CASE(test_wildcard_tree_remove) { tfs::game::wildcardtree::add("test"); - BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("test").first, WildcardTreeNode::Found); + BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("test").first, WildcardTreeSearchResult::Found); BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("test").second, "test"); tfs::game::wildcardtree::remove("test"); - BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("test").first, WildcardTreeNode::NotFound); + BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("test").first, WildcardTreeSearchResult::NotFound); } BOOST_AUTO_TEST_CASE(test_wildcard_tree_partial_search) @@ -49,18 +49,18 @@ BOOST_AUTO_TEST_CASE(test_wildcard_tree_partial_search) tfs::game::wildcardtree::add("test"); tfs::game::wildcardtree::add("te"); - BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("te").first, WildcardTreeNode::Ambiguous); + BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("te").first, WildcardTreeSearchResult::Ambiguous); BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("te").second, ""); - BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("test").first, WildcardTreeNode::Found); + BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("test").first, WildcardTreeSearchResult::Found); BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("test").second, "test"); tfs::game::wildcardtree::remove("test"); - BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("te").first, WildcardTreeNode::Found); + BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("te").first, WildcardTreeSearchResult::Found); BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("te").second, "te"); - BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("test").first, WildcardTreeNode::NotFound); + BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("test").first, WildcardTreeSearchResult::NotFound); BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("test").second, ""); } @@ -70,9 +70,9 @@ BOOST_AUTO_TEST_CASE(test_wildcard_tree_search_after_remove) tfs::game::wildcardtree::add("te"); tfs::game::wildcardtree::remove("test"); - BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("test").first, WildcardTreeNode::NotFound); + BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("test").first, WildcardTreeSearchResult::NotFound); BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("test").second, ""); - BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("te").first, WildcardTreeNode::Found); + BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("te").first, WildcardTreeSearchResult::Found); BOOST_CHECK_EQUAL(tfs::game::wildcardtree::search("te").second, "te"); }