BlackMATov/enduro2d
1
0
Fork 0
mirror of https://github.com/enduro2d/enduro2d.git synced 2025-12-15 00:11:55 +07:00
Code Issues Packages Projects Releases Wiki Activity

extract parents helper functions

Browse Source
This commit is contained in:
Matvey Cherevko
2020-02-04 07:34:09 +07:00
parent 802ee779a4
commit 8858716359
3 changed files with 236 additions and 65 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
headers/enduro2d/high/node.hpp
View File

@@ -170,6 +170,16 @@ namespace e2d::nodes
std::size_t extract_nodes_reversed(const node_iptr& root, Iter iter);
template < typename Iter >
std::size_t extract_nodes_reversed(const const_node_iptr& root, Iter iter);
template < typename Iter >
std::size_t extract_parents(const node_iptr& root, Iter iter);
template < typename Iter >
std::size_t extract_parents(const const_node_iptr& root, Iter iter);
template < typename Iter >
std::size_t extract_parents_reversed(const node_iptr& root, Iter iter);
template < typename Iter >
std::size_t extract_parents_reversed(const const_node_iptr& root, Iter iter);
}
namespace e2d::nodes
@@ -179,6 +189,12 @@ namespace e2d::nodes
vector<node_iptr> extract_nodes_reversed(const node_iptr& root);
vector<const_node_iptr> extract_nodes_reversed(const const_node_iptr& root);
vector<node_iptr> extract_parents(const node_iptr& root);
vector<const_node_iptr> extract_parents(const const_node_iptr& root);
vector<node_iptr> extract_parents_reversed(const node_iptr& root);
vector<const_node_iptr> extract_parents_reversed(const const_node_iptr& root);
}
namespace e2d::nodes
@@ -192,6 +208,16 @@ namespace e2d::nodes
void for_extracted_nodes_reversed(const node_iptr& root, F&& f);
template < typename F >
void for_extracted_nodes_reversed(const const_node_iptr& root, F&& f);
template < typename F >
void for_extracted_parents(const node_iptr& parents, F&& f);
template < typename F >
void for_extracted_parents(const const_node_iptr& parents, F&& f);
template < typename F >
void for_extracted_parents_reversed(const node_iptr& parents, F&& f);
template < typename F >
void for_extracted_parents_reversed(const const_node_iptr& parents, F&& f);
}
namespace e2d::nodes

248
headers/enduro2d/high/node.inl
View File

@@ -94,114 +94,232 @@ namespace e2d::nodes
}
}
namespace e2d::nodes
{
template < typename Iter >
std::size_t extract_parents(const node_iptr& root, Iter iter) {
std::size_t count{0u};
if ( root ) {
++count;
iter++ = root;
count += extract_parents(root->parent(), iter);
}
return count;
}
template < typename Iter >
std::size_t extract_parents(const const_node_iptr& root, Iter iter) {
std::size_t count{0u};
if ( root ) {
++count;
iter++ = root;
count += extract_parents(root->parent(), iter);
}
return count;
}
template < typename Iter >
std::size_t extract_parents_reversed(const node_iptr& root, Iter iter) {
std::size_t count{0u};
if ( root ) {
count += extract_parents(root->parent(), iter);
++count;
iter++ = root;
}
return count;
}
template < typename Iter >
std::size_t extract_parents_reversed(const const_node_iptr& root, Iter iter) {
std::size_t count{0u};
if ( root ) {
count += extract_parents(root->parent(), iter);
++count;
iter++ = root;
}
return count;
}
}
namespace e2d::nodes
{
template < typename F >
void for_extracted_nodes(const node_iptr& root, F&& f) {
//TODO(BlackMat): replace it to frame allocator
static thread_local vector<node_iptr> nodes;
const std::size_t begin_index = nodes.size();
try {
extract_nodes(
root,
std::back_inserter(nodes));
const std::size_t end_index = nodes.size();
for ( std::size_t i = begin_index; i < end_index; ++i ) {
f(nodes[i]);
}
} catch (...) {
E2D_DEFER([begin_index](){
nodes.erase(
nodes.begin() + begin_index,
nodes.end());
throw;
}
});
nodes.erase(
nodes.begin() + begin_index,
nodes.end());
extract_nodes(
root,
std::back_inserter(nodes));
const std::size_t end_index = nodes.size();
for ( std::size_t i = begin_index; i < end_index; ++i ) {
f(nodes[i]);
}
}
template < typename F >
void for_extracted_nodes(const const_node_iptr& root, F&& f) {
//TODO(BlackMat): replace it to frame allocator
static thread_local vector<const_node_iptr> nodes;
const std::size_t begin_index = nodes.size();
try {
extract_nodes(
root,
std::back_inserter(nodes));
const std::size_t end_index = nodes.size();
for ( std::size_t i = begin_index; i < end_index; ++i ) {
f(nodes[i]);
}
} catch (...) {
E2D_DEFER([begin_index](){
nodes.erase(
nodes.begin() + begin_index,
nodes.end());
throw;
}
});
nodes.erase(
nodes.begin() + begin_index,
nodes.end());
extract_nodes(
root,
std::back_inserter(nodes));
const std::size_t end_index = nodes.size();
for ( std::size_t i = begin_index; i < end_index; ++i ) {
f(nodes[i]);
}
}
template < typename F >
void for_extracted_nodes_reversed(const node_iptr& root, F&& f) {
//TODO(BlackMat): replace it to frame allocator
static thread_local vector<node_iptr> nodes;
const std::size_t begin_index = nodes.size();
try {
extract_nodes_reversed(
root,
std::back_inserter(nodes));
const std::size_t end_index = nodes.size();
for ( std::size_t i = begin_index; i < end_index; ++i ) {
f(nodes[i]);
}
} catch (...) {
E2D_DEFER([begin_index](){
nodes.erase(
nodes.begin() + begin_index,
nodes.end());
throw;
}
});
nodes.erase(
nodes.begin() + begin_index,
nodes.end());
extract_nodes_reversed(
root,
std::back_inserter(nodes));
const std::size_t end_index = nodes.size();
for ( std::size_t i = begin_index; i < end_index; ++i ) {
f(nodes[i]);
}
}
template < typename F >
void for_extracted_nodes_reversed(const const_node_iptr& root, F&& f) {
//TODO(BlackMat): replace it to frame allocator
static thread_local vector<const_node_iptr> nodes;
const std::size_t begin_index = nodes.size();
try {
extract_nodes_reversed(
root,
std::back_inserter(nodes));
const std::size_t end_index = nodes.size();
for ( std::size_t i = begin_index; i < end_index; ++i ) {
f(nodes[i]);
}
} catch (...) {
E2D_DEFER([begin_index](){
nodes.erase(
nodes.begin() + begin_index,
nodes.end());
throw;
}
});
nodes.erase(
nodes.begin() + begin_index,
nodes.end());
extract_nodes_reversed(
root,
std::back_inserter(nodes));
const std::size_t end_index = nodes.size();
for ( std::size_t i = begin_index; i < end_index; ++i ) {
f(nodes[i]);
}
}
}
namespace e2d::nodes
{
template < typename F >
void for_extracted_parents(const node_iptr& root, F&& f) {
//TODO(BlackMat): replace it to frame allocator
static thread_local vector<node_iptr> parents;
const std::size_t begin_index = parents.size();
E2D_DEFER([begin_index](){
parents.erase(
parents.begin() + begin_index,
parents.end());
});
extract_parents(
root,
std::back_inserter(parents));
const std::size_t end_index = parents.size();
for ( std::size_t i = begin_index; i < end_index; ++i ) {
f(parents[i]);
}
}
template < typename F >
void for_extracted_parents(const const_node_iptr& root, F&& f) {
//TODO(BlackMat): replace it to frame allocator
static thread_local vector<const_node_iptr> parents;
const std::size_t begin_index = parents.size();
E2D_DEFER([begin_index](){
parents.erase(
parents.begin() + begin_index,
parents.end());
});
extract_parents(
root,
std::back_inserter(parents));
const std::size_t end_index = parents.size();
for ( std::size_t i = begin_index; i < end_index; ++i ) {
f(parents[i]);
}
}
template < typename F >
void for_extracted_parents_reversed(const node_iptr& root, F&& f) {
//TODO(BlackMat): replace it to frame allocator
static thread_local vector<node_iptr> parents;
const std::size_t begin_index = parents.size();
E2D_DEFER([begin_index](){
parents.erase(
parents.begin() + begin_index,
parents.end());
});
extract_parents_reversed(
root,
std::back_inserter(parents));
const std::size_t end_index = parents.size();
for ( std::size_t i = begin_index; i < end_index; ++i ) {
f(parents[i]);
}
}
template < typename F >
void for_extracted_parents_reversed(const const_node_iptr& root, F&& f) {
//TODO(BlackMat): replace it to frame allocator
static thread_local vector<const_node_iptr> parents;
const std::size_t begin_index = parents.size();
E2D_DEFER([begin_index](){
parents.erase(
parents.begin() + begin_index,
parents.end());
});
extract_parents_reversed(
root,
std::back_inserter(parents));
const std::size_t end_index = parents.size();
for ( std::size_t i = begin_index; i < end_index; ++i ) {
f(parents[i]);
}
}
}
@@ -233,7 +351,7 @@ namespace e2d::nodes
iter++ = component;
}
return count + get_components_in_parent(root->parent(), iter);
return count + get_components_in_parent<Component>(root->parent(), iter);
}
template < typename Component >

27
sources/enduro2d/high/node.cpp
View File

@@ -470,3 +470,30 @@ namespace e2d::nodes
return nodes;
}
}
namespace e2d::nodes
{
vector<node_iptr> extract_parents(const node_iptr& child) {
vector<node_iptr> parents;
extract_parents(child, std::back_inserter(parents));
return parents;
}
vector<const_node_iptr> extract_parents(const const_node_iptr& child) {
vector<const_node_iptr> parents;
extract_parents(child, std::back_inserter(parents));
return parents;
}
vector<node_iptr> extract_parents_reversed(const node_iptr& child) {
vector<node_iptr> parents;
extract_parents_reversed(child, std::back_inserter(parents));
return parents;
}
vector<const_node_iptr> extract_parents_reversed(const const_node_iptr& child) {
vector<const_node_iptr> parents;
extract_parents_reversed(child, std::back_inserter(parents));
return parents;
}
}