blob: 4adc92c0bef3b31f76c8a9bb03feac22ab0f3e5f (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
|
// Copyright (C) by Josh Blum. See LICENSE.txt for licensing information.
#include "element_impl.hpp"
#include <gras/element.hpp>
#include <boost/format.hpp>
#include <boost/detail/atomic_count.hpp>
#include <boost/foreach.hpp>
#include <boost/algorithm/string.hpp>
static boost::detail::atomic_count unique_id_pool(0);
using namespace gras;
Element::Element(void)
{
//NOP
}
Element::Element(const std::string &name)
{
this->reset(new ElementImpl());
(*this)->name = name;
(*this)->unique_id = ++unique_id_pool;
(*this)->id = str(boost::format("%s(%d)") % this->name() % this->unique_id());
if (GENESIS) std::cerr << "New element: " << to_string() << std::endl;
}
ElementImpl::~ElementImpl(void)
{
if (this->executor) this->top_block_cleanup();
if (this->topology) this->hier_block_cleanup();
if (this->block) this->block_cleanup();
}
long Element::unique_id(void) const
{
return (*this)->unique_id;
}
std::string Element::name(void) const
{
return (*this)->name;
}
std::string Element::to_string(void) const
{
return (*this)->id;
}
void Element::adopt_element(const std::string &name, const Element &child)
{
if (child->parent) throw std::invalid_argument(str(boost::format(
"Could not register child %s into %s.\n"
"The child %s already has parent %s.\n"
)
% child.to_string()
% this->to_string()
% child.to_string()
% child->parent.to_string()
));
if ((*this)->children.count(name)) throw std::invalid_argument(str(boost::format(
"A child of name %s already registered to element %s"
)
% child.to_string()
% this->to_string()
));
child->parent = *this;
(*this)->children[name] = child;
}
Block *Element::locate_block(const std::string &path)
{
//split the paths into nodes
std::vector<std::string> nodes;
boost::split(nodes, path, boost::is_any_of("/"));
//iterate through the path to find the element
boost::shared_ptr<ElementImpl> elem = *this;
size_t i = 0;
BOOST_FOREACH(const std::string &node, nodes)
{
i++;
if (node == "" and i == 1) //find root
{
while (elem->parent) elem = elem->parent;
continue;
}
if (node == ".") //this dir
{
continue;
}
if (node == "..") //up a dir
{
if (not elem->parent) throw std::invalid_argument(
"Element tree lookup fail - null parent: " + path
);
elem = elem->parent;
continue;
}
if (elem->children.count(node) == 0) throw std::invalid_argument(
"Element tree lookup fail - no such path: " + path
);
elem = elem->children[node];
}
//return block ptr as result
return elem->block->block_ptr;
}
|
