blob: 0d8a60686ab11b982c428879a7aa35329c552321 [file] [log] [blame]
Václav Kubernát24df80e2018-06-06 15:18:03 +02001/*
2 * Copyright (C) 2018 CESNET, https://photonics.cesnet.cz/
3 * Copyright (C) 2018 FIT CVUT, https://fit.cvut.cz/
4 *
5 * Written by Václav Kubernát <kubervac@fit.cvut.cz>
6 *
7*/
8
9#include <experimental/iterator>
Václav Kubernát509ce652019-05-29 19:46:44 +020010#include <sstream>
Václav Kubernát24df80e2018-06-06 15:18:03 +020011#include "ast_path.hpp"
12#include "utils.hpp"
13
14container_::container_(const std::string& name)
15 : m_name(name)
16{
17}
18
19bool container_::operator==(const container_& b) const
20{
21 return this->m_name == b.m_name;
22}
23
24leaf_::leaf_(const std::string& name)
25 : m_name(name)
26{
27}
28
Václav Kubernát5b8a8f32020-05-20 00:57:22 +020029bool leafListElement_::operator==(const leafListElement_& b) const
30{
31 return this->m_name == b.m_name && this->m_value == b.m_value;
32}
33
Václav Kubernát5b8a8f32020-05-20 00:57:22 +020034leafList_::leafList_(const std::string& name)
35 : m_name(name)
36{
37}
38
39bool leafList_::operator==(const leafList_& b) const
40{
41 return this->m_name == b.m_name;
42}
43
Václav Kubernát744f57f2018-06-29 22:46:26 +020044bool module_::operator==(const module_& b) const
45{
46 return this->m_name == b.m_name;
47}
48
Václav Kubernát2eaceb82018-10-08 19:56:30 +020049dataNode_::dataNode_() = default;
Václav Kubernát744f57f2018-06-29 22:46:26 +020050
Václav Kubernát2eaceb82018-10-08 19:56:30 +020051dataNode_::dataNode_(decltype(m_suffix) node)
Václav Kubernát744f57f2018-06-29 22:46:26 +020052 : m_suffix(node)
53{
54}
55
Václav Kubernát2eaceb82018-10-08 19:56:30 +020056dataNode_::dataNode_(module_ module, decltype(m_suffix) node)
Václav Kubernát744f57f2018-06-29 22:46:26 +020057 : m_prefix(module)
58 , m_suffix(node)
59{
60}
61
Václav Kubernát2db124c2020-05-28 21:58:36 +020062dataNode_::dataNode_(boost::optional<module_> module, decltype(m_suffix) node)
63 : m_prefix(module)
64 , m_suffix(node)
65{
66
67}
68
Václav Kubernát5c75b252018-10-10 18:33:47 +020069schemaNode_::schemaNode_(decltype(m_suffix) node)
70 : m_suffix(node)
71{
72}
73
Václav Kubernát2eaceb82018-10-08 19:56:30 +020074schemaNode_::schemaNode_(module_ module, decltype(m_suffix) node)
75 : m_prefix(module)
76 , m_suffix(node)
77{
78}
Václav Kubernát744f57f2018-06-29 22:46:26 +020079
Václav Kubernát2eaceb82018-10-08 19:56:30 +020080schemaNode_::schemaNode_() = default;
81
82bool schemaNode_::operator==(const schemaNode_& b) const
83{
84 return this->m_suffix == b.m_suffix && this->m_prefix == b.m_prefix;
85}
86
87bool dataNode_::operator==(const dataNode_& b) const
Václav Kubernát744f57f2018-06-29 22:46:26 +020088{
89 return this->m_suffix == b.m_suffix && this->m_prefix == b.m_prefix;
90}
91
Václav Kubernát24df80e2018-06-06 15:18:03 +020092bool leaf_::operator==(const leaf_& b) const
93{
94 return this->m_name == b.m_name;
95}
96
Václav Kubernátc15fe822020-06-04 11:28:39 +020097listElement_::listElement_(const std::string& listName, const ListInstance& keys)
Václav Kubernát24df80e2018-06-06 15:18:03 +020098 : m_name(listName)
99 , m_keys(keys)
100{
101}
102
103bool listElement_::operator==(const listElement_& b) const
104{
105 return (this->m_name == b.m_name && this->m_keys == b.m_keys);
106}
107
Václav Kubernát2eaceb82018-10-08 19:56:30 +0200108bool list_::operator==(const list_& b) const
109{
110 return (this->m_name == b.m_name);
111}
112
113list_::list_(const std::string& listName)
114 : m_name(listName)
115{
116}
117
Jan Kundrát97376f72020-06-15 19:26:31 +0200118namespace {
119template <typename T, typename U>
120auto findFirstOf(const std::vector<U>& nodes)
121{
122 return std::find_if(nodes.begin(), nodes.end(), [](const auto& e) {
123 return std::holds_alternative<T>(e.m_suffix);
124 });
125}
126
127template <typename T>
128void validatePathNodes(const std::vector<T>& nodes)
129{
130 static_assert(std::is_same<T, dataNode_>() || std::is_same<T, schemaNode_>());
131
132 if (nodes.empty()) {
133 // there are default ctors, so it makes sense to specify the same thing via explicit args and not fail
134 return;
135 }
136
137 if (auto firstLeaf = findFirstOf<leaf_>(nodes);
138 firstLeaf != nodes.end() && firstLeaf != nodes.end() - 1) {
139 throw std::logic_error{"Cannot put any extra nodes after a leaf"};
140 }
141
142 if (auto firstLeafList = findFirstOf<leafList_>(nodes);
143 firstLeafList != nodes.end() && firstLeafList != nodes.end() - 1) {
144 throw std::logic_error{"Cannot put any extra nodes after a leaf-list"};
145 }
146
147 if constexpr (std::is_same<T, dataNode_>()) {
148 if (auto firstLeafListElements = findFirstOf<leafListElement_>(nodes);
149 firstLeafListElements != nodes.end() && firstLeafListElements != nodes.end() - 1) {
150 throw std::logic_error{"Cannot put any extra nodes after a leaf-list with element specification"};
151 }
152 if (auto firstList = findFirstOf<list_>(nodes);
153 firstList != nodes.end() && firstList != nodes.end() - 1) {
154 throw std::logic_error{
155 "A list with no key specification can be present only as a last item in a dataPath. Did you mean to use a schemaPath?"
156 };
157 }
158 }
159}
160}
161
162schemaPath_::schemaPath_()
163{
164}
165
166schemaPath_::schemaPath_(const Scope scope, const std::vector<schemaNode_>& nodes, const TrailingSlash trailingSlash)
167 : m_scope(scope)
168 , m_nodes(nodes)
169 , m_trailingSlash(trailingSlash)
170{
171 validatePathNodes(m_nodes);
172}
173
Václav Kubernát2eaceb82018-10-08 19:56:30 +0200174bool schemaPath_::operator==(const schemaPath_& b) const
175{
176 if (this->m_nodes.size() != b.m_nodes.size())
177 return false;
178 return this->m_nodes == b.m_nodes;
179}
180
Jan Kundrát97376f72020-06-15 19:26:31 +0200181dataPath_::dataPath_()
182{
183}
184
185dataPath_::dataPath_(const Scope scope, const std::vector<dataNode_>& nodes, const TrailingSlash trailingSlash)
186 : m_scope(scope)
187 , m_nodes(nodes)
188 , m_trailingSlash(trailingSlash)
189{
190 validatePathNodes(m_nodes);
191}
192
Václav Kubernát2eaceb82018-10-08 19:56:30 +0200193bool dataPath_::operator==(const dataPath_& b) const
Václav Kubernát24df80e2018-06-06 15:18:03 +0200194{
195 if (this->m_nodes.size() != b.m_nodes.size())
196 return false;
197 return this->m_nodes == b.m_nodes;
198}
199
Václav Kubernátb5ca1542020-05-27 01:03:54 +0200200struct nodeToSchemaStringVisitor {
Václav Kubernát24df80e2018-06-06 15:18:03 +0200201 std::string operator()(const nodeup_&) const
202 {
203 return "..";
204 }
205 template <class T>
206 std::string operator()(const T& node) const
207 {
208 return node.m_name;
209 }
210};
Jan Kundrát2a8f4332018-09-14 17:05:31 +0200211
212std::string escapeListKeyString(const std::string& what)
213{
214 // If we have both single and double quote, then we're screwed, but that "shouldn't happen"
215 // in <= YANG 1.1 due to limitations in XPath 1.0.
216 if (what.find('\'') != std::string::npos) {
217 return '\"' + what + '\"';
218 } else {
219 return '\'' + what + '\'';
220 }
221}
222
Václav Kubernátb5ca1542020-05-27 01:03:54 +0200223struct nodeToDataStringVisitor {
Václav Kubernát24df80e2018-06-06 15:18:03 +0200224 std::string operator()(const listElement_& node) const
225 {
226 std::ostringstream res;
227 res << node.m_name + "[";
228 std::transform(node.m_keys.begin(), node.m_keys.end(),
Václav Kubernát5395e712019-12-03 18:24:33 +0100229 std::experimental::make_ostream_joiner(res, "]["),
Václav Kubernát7707cae2020-01-16 12:04:53 +0100230 [] (const auto& it) { return it.first + "=" + escapeListKeyString(leafDataToString(it.second)); });
Václav Kubernát24df80e2018-06-06 15:18:03 +0200231 res << "]";
Václav Kubernátebca2552018-06-08 19:06:02 +0200232 return res.str();
Václav Kubernát24df80e2018-06-06 15:18:03 +0200233 }
Václav Kubernát5b8a8f32020-05-20 00:57:22 +0200234 std::string operator()(const leafListElement_& node) const
235 {
236 return node.m_name + "[.=" + escapeListKeyString(leafDataToString(node.m_value)) + "]";
237 }
Václav Kubernát24df80e2018-06-06 15:18:03 +0200238 std::string operator()(const nodeup_&) const
239 {
240 return "..";
241 }
242 template <class T>
243 std::string operator()(const T& node) const
244 {
245 return node.m_name;
246 }
247};
248
Václav Kubernát2eaceb82018-10-08 19:56:30 +0200249std::string nodeToSchemaString(decltype(dataPath_::m_nodes)::value_type node)
Václav Kubernát744f57f2018-06-29 22:46:26 +0200250{
Václav Kubernátb5ca1542020-05-27 01:03:54 +0200251 return std::visit(nodeToSchemaStringVisitor(), node.m_suffix);
Václav Kubernát744f57f2018-06-29 22:46:26 +0200252}
253
Václav Kubernátefcac932020-01-10 15:26:32 +0100254std::string pathToDataString(const dataPath_& path, Prefixes prefixes)
Václav Kubernát24df80e2018-06-06 15:18:03 +0200255{
256 std::string res;
Václav Kubernát5395e712019-12-03 18:24:33 +0100257 if (path.m_scope == Scope::Absolute) {
258 res = "/";
259 }
Václav Kubernátefcac932020-01-10 15:26:32 +0100260
Václav Kubernátef085742020-04-21 09:28:44 +0200261 for (const auto& it : path.m_nodes) {
Václav Kubernát744f57f2018-06-29 22:46:26 +0200262 if (it.m_prefix)
Václav Kubernátb5ca1542020-05-27 01:03:54 +0200263 res = joinPaths(res, it.m_prefix.value().m_name + ":" + std::visit(nodeToDataStringVisitor(), it.m_suffix));
Václav Kubernát744f57f2018-06-29 22:46:26 +0200264 else
Václav Kubernátb5ca1542020-05-27 01:03:54 +0200265 res = joinPaths(res, (prefixes == Prefixes::Always ? path.m_nodes.at(0).m_prefix.value().m_name + ":" : "") + std::visit(nodeToDataStringVisitor(), it.m_suffix));
Václav Kubernátefcac932020-01-10 15:26:32 +0100266 }
Václav Kubernát744f57f2018-06-29 22:46:26 +0200267
268 return res;
269}
270
Václav Kubernátefcac932020-01-10 15:26:32 +0100271std::string pathToSchemaString(const schemaPath_& path, Prefixes prefixes)
Václav Kubernát744f57f2018-06-29 22:46:26 +0200272{
273 std::string res;
Václav Kubernátefcac932020-01-10 15:26:32 +0100274 if (path.m_scope == Scope::Absolute) {
275 res = "/";
Václav Kubernát744f57f2018-06-29 22:46:26 +0200276 }
277
Václav Kubernátef085742020-04-21 09:28:44 +0200278 for (const auto& it : path.m_nodes) {
Václav Kubernát744f57f2018-06-29 22:46:26 +0200279 if (it.m_prefix)
Václav Kubernátb5ca1542020-05-27 01:03:54 +0200280 res = joinPaths(res, it.m_prefix.value().m_name + ":" + std::visit(nodeToSchemaStringVisitor(), it.m_suffix));
Václav Kubernát744f57f2018-06-29 22:46:26 +0200281 else
Václav Kubernátb5ca1542020-05-27 01:03:54 +0200282 res = joinPaths(res, (prefixes == Prefixes::Always ? path.m_nodes.at(0).m_prefix.value().m_name + ":" : "") + std::visit(nodeToSchemaStringVisitor(), it.m_suffix));
Václav Kubernát744f57f2018-06-29 22:46:26 +0200283 }
Václav Kubernát24df80e2018-06-06 15:18:03 +0200284 return res;
285}
286
Václav Kubernátefcac932020-01-10 15:26:32 +0100287std::string pathToSchemaString(const dataPath_& path, Prefixes prefixes)
Václav Kubernát24df80e2018-06-06 15:18:03 +0200288{
Václav Kubernátefcac932020-01-10 15:26:32 +0100289 return pathToSchemaString(dataPathToSchemaPath(path), prefixes);
Václav Kubernát5c75b252018-10-10 18:33:47 +0200290}
291
Václav Kubernátb5ca1542020-05-27 01:03:54 +0200292struct dataSuffixToSchemaSuffix {
293 using ReturnType = decltype(schemaNode_::m_suffix);
294 ReturnType operator()(const listElement_& listElement) const
Václav Kubernát2eaceb82018-10-08 19:56:30 +0200295 {
296 return list_{listElement.m_name};
297 }
298
Václav Kubernátb5ca1542020-05-27 01:03:54 +0200299 ReturnType operator()(const leafListElement_& leafListElement) const
Václav Kubernát5b8a8f32020-05-20 00:57:22 +0200300 {
301 return leafList_{leafListElement.m_name};
302 }
303
Václav Kubernát2eaceb82018-10-08 19:56:30 +0200304 template <typename T>
Václav Kubernátb5ca1542020-05-27 01:03:54 +0200305 ReturnType operator()(const T& suffix) const
Václav Kubernát2eaceb82018-10-08 19:56:30 +0200306 {
307 return suffix;
308 }
309};
310
311schemaNode_ dataNodeToSchemaNode(const dataNode_& node)
312{
313 schemaNode_ res;
314 res.m_prefix = node.m_prefix;
Václav Kubernátb5ca1542020-05-27 01:03:54 +0200315 res.m_suffix = std::visit(dataSuffixToSchemaSuffix(), node.m_suffix);
Václav Kubernát2eaceb82018-10-08 19:56:30 +0200316 return res;
317}
318
319schemaPath_ dataPathToSchemaPath(const dataPath_& path)
320{
Václav Kubernátbf083ec2019-02-19 13:58:09 +0100321 schemaPath_ res{path.m_scope, {}};
Václav Kubernát2eaceb82018-10-08 19:56:30 +0200322
Václav Kubernátbf083ec2019-02-19 13:58:09 +0100323 std::transform(path.m_nodes.begin(), path.m_nodes.end(),
324 std::back_inserter(res.m_nodes),
325 [](const dataNode_& node) { return dataNodeToSchemaNode(node); });
Václav Kubernát2eaceb82018-10-08 19:56:30 +0200326
Václav Kubernátbf083ec2019-02-19 13:58:09 +0100327 return res;
Václav Kubernát2eaceb82018-10-08 19:56:30 +0200328}
Václav Kubernáte781b902020-06-15 14:35:11 +0200329
330namespace {
331template <typename NodeType>
332void impl_pushFragment(std::vector<NodeType>& where, const NodeType& what)
333{
334 if (std::holds_alternative<nodeup_>(what.m_suffix)) {
335 if (!where.empty()) { // Allow going up, when already at root
336 where.pop_back();
337 }
338 } else {
339 where.push_back(what);
340 }
341}
342}
343
344void schemaPath_::pushFragment(const schemaNode_& fragment)
345{
346 impl_pushFragment(m_nodes, fragment);
Jan Kundrát97376f72020-06-15 19:26:31 +0200347 validatePathNodes(m_nodes);
Václav Kubernáte781b902020-06-15 14:35:11 +0200348}
349
350void dataPath_::pushFragment(const dataNode_& fragment)
351{
352 impl_pushFragment(m_nodes, fragment);
Jan Kundrát97376f72020-06-15 19:26:31 +0200353 validatePathNodes(m_nodes);
Václav Kubernáte781b902020-06-15 14:35:11 +0200354}