forked from organicmaps/organicmaps
[indexer] Added methods for tree node, added class Forest.
This commit is contained in:
Maksim Andrianov
gmoryes
parent
3d01e9af23
commit
2c5e0865dc
2 changed files with 272 additions and 0 deletions
|
|
@ -2,6 +2,7 @@
|
|||
|
||||
#include <algorithm>
|
||||
#include <memory>
|
||||
#include <sstream>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
|
|
@ -126,4 +127,156 @@ size_t Size(types::Ptr<Data> const & node)
|
|||
PreOrderVisit(node, [&](auto const &) { ++size; });
|
||||
return size;
|
||||
}
|
||||
|
||||
template <typename Data>
|
||||
decltype(auto) GetRoot(types::Ptr<Data> node)
|
||||
{
|
||||
while (node->HasParent())
|
||||
node = node->GetParent();
|
||||
return node;
|
||||
}
|
||||
|
||||
template <typename Data>
|
||||
decltype(auto) GetPath(types::Ptr<Data> node)
|
||||
{
|
||||
types::PtrList<Data> path;
|
||||
while (node)
|
||||
{
|
||||
path.emplace_back(node);
|
||||
node = node->GetParent();
|
||||
}
|
||||
return path;
|
||||
}
|
||||
|
||||
template <typename Data, typename Fn>
|
||||
types::Ptr<typename std::result_of<Fn(Data const &)>::type> TransformToTree(
|
||||
types::Ptr<Data> const & node, Fn && fn)
|
||||
{
|
||||
auto n = MakeTreeNode(fn(node->GetData()));
|
||||
for (auto const & ch : node->GetChildren())
|
||||
n->AddChild(TransformToTree(ch, fn));
|
||||
return n;
|
||||
}
|
||||
|
||||
template <typename Data>
|
||||
bool IsEqual(types::Ptr<Data> const & lhs, types::Ptr<Data> const & rhs)
|
||||
{
|
||||
if (lhs->GetData() != rhs->GetData())
|
||||
return false;
|
||||
|
||||
auto const & lhsCh = lhs->GetChildren();
|
||||
auto const & rhsCh = rhs->GetChildren();
|
||||
if (lhsCh.size() != rhsCh.size())
|
||||
return false;
|
||||
|
||||
for (size_t i = 0; i < lhsCh.size(); ++i)
|
||||
{
|
||||
if (!IsEqual(lhsCh[i], rhsCh[i]))
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
template <typename Data, typename Fn>
|
||||
size_t CountIf(types::Ptr<Data> const & node, Fn && fn)
|
||||
{
|
||||
size_t count = 0;
|
||||
PreOrderVisit(node, [&](auto const & node) {
|
||||
if (fn(node->GetData()))
|
||||
++count;
|
||||
});
|
||||
return count;
|
||||
}
|
||||
|
||||
template <typename Data>
|
||||
void Print(types::Ptr<Data> const & node, std::ostream & stream,
|
||||
std::string prefix = "", bool isTail = true)
|
||||
{
|
||||
stream << prefix;
|
||||
if (isTail)
|
||||
{
|
||||
stream << "└───";
|
||||
prefix += " ";
|
||||
}
|
||||
else
|
||||
{
|
||||
stream << "├───";
|
||||
prefix += "│ ";
|
||||
}
|
||||
auto str = DebugPrint(node->GetData());
|
||||
std::replace(std::begin(str), std::end(str), '\n', '|');
|
||||
stream << str << '\n';
|
||||
auto const & children = node->GetChildren();
|
||||
size_t size = children.size();
|
||||
for (size_t i = 0; i < size; ++i)
|
||||
Print(children[i], stream, prefix, i == size - 1 /* isTail */);
|
||||
}
|
||||
|
||||
template <typename Data>
|
||||
std::string DebugPrint(types::Ptr<Data> const & node)
|
||||
{
|
||||
std::stringstream stream;
|
||||
Print(node, stream);
|
||||
return stream.str();
|
||||
}
|
||||
|
||||
template <typename Data>
|
||||
class Forest
|
||||
{
|
||||
public:
|
||||
bool operator==(Forest<Data> const & other) const
|
||||
{
|
||||
auto const size = Size();
|
||||
if (size != other.Size())
|
||||
return false;
|
||||
|
||||
for (size_t i = 0; i < size; ++i)
|
||||
{
|
||||
if (!IsEqual(m_trees[i], other.m_trees[i]))
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool operator!=(Forest<Data> const & other) const { return !(*this == other); }
|
||||
|
||||
void Append(types::Ptr<Data> const & tree) { m_trees.emplace_back(tree); }
|
||||
|
||||
size_t Size() const { return m_trees.size(); }
|
||||
|
||||
template <typename Fn>
|
||||
void ForEachTree(Fn && fn) const
|
||||
{
|
||||
base::ControlFlowWrapper<Fn> wrapper(std::forward<Fn>(fn));
|
||||
for (auto const & tree : m_trees)
|
||||
{
|
||||
if (wrapper(tree) == base::ControlFlow::Break)
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
types::PtrList<Data> m_trees;
|
||||
};
|
||||
|
||||
template <typename Data, typename Fn>
|
||||
decltype(auto) FindIf(Forest<Data> const & forest, Fn && fn)
|
||||
{
|
||||
types::Ptr<Data> res = nullptr;
|
||||
forest.ForEachTree([&](auto const & tree) {
|
||||
res = FindIf(tree, fn);
|
||||
return res ? base::ControlFlow::Break : base::ControlFlow::Continue;
|
||||
});
|
||||
return res;
|
||||
}
|
||||
|
||||
template <typename Data>
|
||||
std::string DebugPrint(Forest<Data> const & forest)
|
||||
{
|
||||
std::stringstream stream;
|
||||
forest.ForEachTree([&](auto const & tree) {
|
||||
stream << DebugPrint(tree) << '\n';
|
||||
});
|
||||
return stream.str();
|
||||
}
|
||||
} // namespace tree_node
|
||||
|
|
|
|||
|
|
@ -6,6 +6,7 @@
|
|||
|
||||
#include <iterator>
|
||||
#include <list>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
namespace
|
||||
|
|
@ -81,4 +82,122 @@ UNIT_TEST(TreeNode_GetDepth)
|
|||
depth = tree_node::GetDepth(tree_node::FindIf(tree, [](auto const & d) { return d == 36; }));
|
||||
TEST_EQUAL(depth, 3, ());
|
||||
}
|
||||
|
||||
UNIT_TEST(TreeNode_GetRoot)
|
||||
{
|
||||
auto const tree = MakeTree();
|
||||
auto const node22 = tree_node::FindIf(tree, [](auto const & d) { return d == 22; });
|
||||
auto const root = tree_node::GetRoot(node22);
|
||||
TEST(tree, ());
|
||||
TEST_EQUAL(tree->GetData(), root->GetData(), ());
|
||||
}
|
||||
|
||||
UNIT_TEST(TreeNode_GetPath)
|
||||
{
|
||||
auto const tree = MakeTree();
|
||||
auto const node33 = tree_node::FindIf(tree, [](auto const & d) { return d == 33; });
|
||||
auto const path = tree_node::GetPath(node33);
|
||||
tree_node::types::PtrList<int> expected = {
|
||||
tree_node::FindIf(tree, [](auto const & d) { return d == 33; }),
|
||||
tree_node::FindIf(tree, [](auto const & d) { return d == 21; }),
|
||||
tree_node::FindIf(tree, [](auto const & d) { return d == 1; })
|
||||
};
|
||||
TEST_EQUAL(path, expected, ());
|
||||
}
|
||||
|
||||
UNIT_TEST(TreeNode_IsEqual)
|
||||
{
|
||||
auto tree1 = tree_node::MakeTreeNode(1);
|
||||
auto node11 = tree_node::MakeTreeNode(21);
|
||||
tree_node::Link(tree_node::MakeTreeNode(31), node11);
|
||||
tree_node::Link(tree_node::MakeTreeNode(32), node11);
|
||||
tree_node::Link(tree_node::MakeTreeNode(33), node11);
|
||||
tree_node::Link(node11, tree1);
|
||||
|
||||
TEST(tree_node::IsEqual(tree1, tree1), ());
|
||||
TEST(!tree_node::IsEqual(tree1, node11), ());
|
||||
}
|
||||
|
||||
UNIT_TEST(TreeNode_TransformToTree)
|
||||
{
|
||||
auto const tree = MakeTree();
|
||||
auto const newTree = tree_node::TransformToTree(tree, [](auto const & data) {
|
||||
return std::to_string(data);
|
||||
});
|
||||
|
||||
auto expected = tree_node::MakeTreeNode<std::string>("1");
|
||||
auto node11 = tree_node::MakeTreeNode<std::string>("21");
|
||||
tree_node::Link(tree_node::MakeTreeNode<std::string>("31"), node11);
|
||||
tree_node::Link(tree_node::MakeTreeNode<std::string>("32"), node11);
|
||||
tree_node::Link(tree_node::MakeTreeNode<std::string>("33"), node11);
|
||||
tree_node::Link(node11, expected);
|
||||
tree_node::Link(tree_node::MakeTreeNode<std::string>("34"), expected);
|
||||
|
||||
auto tree2 = tree_node::MakeTreeNode<std::string>("22");
|
||||
tree_node::Link(tree_node::MakeTreeNode<std::string>("35"), tree2);
|
||||
tree_node::Link(tree_node::MakeTreeNode<std::string>("36"), tree2);
|
||||
tree_node::Link(tree2, expected);
|
||||
|
||||
TEST(tree_node::IsEqual(newTree, expected), ());
|
||||
}
|
||||
|
||||
UNIT_TEST(TreeNode_CountIf)
|
||||
{
|
||||
auto const tree = MakeTree();
|
||||
auto const count = tree_node::CountIf(tree, [](auto const & data) { return data >= 30; });
|
||||
TEST_EQUAL(count, 6, ());
|
||||
}
|
||||
|
||||
UNIT_TEST(TreeNode_DebugPrint)
|
||||
{
|
||||
auto const tree = MakeTree();
|
||||
LOG(LINFO, (tree_node::DebugPrint(tree)));
|
||||
}
|
||||
|
||||
UNIT_TEST(TreeNode_Forest)
|
||||
{
|
||||
tree_node::Forest<int> forest;
|
||||
std::set<tree_node::types::Ptr<int>> s = {
|
||||
MakeTree(),
|
||||
tree_node::MakeTreeNode(10)
|
||||
};
|
||||
for (auto const & tree : s)
|
||||
forest.Append(tree);
|
||||
|
||||
TEST_EQUAL(forest.Size(), 2, ());
|
||||
forest.ForEachTree([&](auto const & tree) {
|
||||
auto const count = s.erase(tree);
|
||||
TEST_EQUAL(count, 1, ());
|
||||
});
|
||||
TEST(s.empty(), ());
|
||||
|
||||
auto const copy = forest;
|
||||
TEST_EQUAL(copy, forest, ());
|
||||
|
||||
tree_node::Forest<int> empty;
|
||||
TEST_NOT_EQUAL(empty, forest, ());
|
||||
}
|
||||
|
||||
UNIT_TEST(TreeNode_ForestFindIf)
|
||||
{
|
||||
tree_node::Forest<int> forest;
|
||||
forest.Append(MakeTree());
|
||||
forest.Append(tree_node::MakeTreeNode(100));
|
||||
auto const node33 = tree_node::FindIf(forest, [](auto const & d) { return d == 33; });
|
||||
TEST(node33, ());
|
||||
TEST_EQUAL(node33->GetData(), 33, ());
|
||||
|
||||
auto const node100 = tree_node::FindIf(forest, [](auto const & d) { return d == 100; });
|
||||
TEST(node100, ());
|
||||
TEST_EQUAL(node100->GetData(), 100, ());
|
||||
}
|
||||
|
||||
UNIT_TEST(TreeNode_ForestDebugPrint)
|
||||
{
|
||||
tree_node::Forest<int> forest;
|
||||
forest.Append(MakeTree());
|
||||
forest.Append(tree_node::MakeTreeNode(100));
|
||||
forest.Append(tree_node::MakeTreeNode(200));
|
||||
LOG(LINFO, (tree_node::DebugPrint(forest)));
|
||||
}
|
||||
} // namespace
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue