blob: 5501247fd3426664350707465d91ca1917fdc12f [file] [log] [blame]
Václav Kubernát0a2a2e82018-05-11 13:59:12 +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#pragma once
Václav Kubernát195eeea2018-05-18 13:52:36 +020010
Václav Kubernát57272422019-02-08 12:48:24 +010011#include <boost/mpl/for_each.hpp>
Václav Kubernát509ce652019-05-29 19:46:44 +020012#include <boost/spirit/home/x3.hpp>
13#include <boost/spirit/home/x3/support/utility/error_reporting.hpp>
14
15
Václav Kubernát57272422019-02-08 12:48:24 +010016#include "ast_commands.hpp"
Václav Kubernát48fc3832018-05-28 14:21:22 +020017#include "schema.hpp"
Václav Kubernátebca2552018-06-08 19:06:02 +020018#include "utils.hpp"
Václav Kubernát329c6c32019-02-06 16:41:53 +010019namespace x3 = boost::spirit::x3;
20
21struct parser_context_tag;
Václav Kubernát0a2a2e82018-05-11 13:59:12 +020022
Václav Kubernát0a2a2e82018-05-11 13:59:12 +020023struct keyValue_class {
24 template <typename T, typename Iterator, typename Context>
25 void on_success(Iterator const&, Iterator const&, T& ast, Context const& context)
26 {
27 auto& parserContext = x3::get<parser_context_tag>(context);
Václav Kubernát48fc3832018-05-28 14:21:22 +020028 const Schema& schema = parserContext.m_schema;
Václav Kubernát0a2a2e82018-05-11 13:59:12 +020029
30 if (parserContext.m_tmpListKeys.find(ast.first) != parserContext.m_tmpListKeys.end()) {
31 _pass(context) = false;
32 parserContext.m_errorMsg = "Key \"" + ast.first + "\" was entered more than once.";
Václav Kubernát744f57f2018-06-29 22:46:26 +020033 } else if (!schema.listHasKey(parserContext.m_curPath, {parserContext.m_curModule, parserContext.m_tmpListName}, ast.first)) {
Václav Kubernát0a2a2e82018-05-11 13:59:12 +020034 _pass(context) = false;
35 parserContext.m_errorMsg = parserContext.m_tmpListName + " is not indexed by \"" + ast.first + "\".";
Václav Kubernát41378452018-06-06 16:29:40 +020036 } else {
37 parserContext.m_tmpListKeys.insert(ast.first);
Václav Kubernát0a2a2e82018-05-11 13:59:12 +020038 }
39 }
Václav Kubernát41378452018-06-06 16:29:40 +020040
41 template <typename Iterator, typename Exception, typename Context>
42 x3::error_handler_result on_error(Iterator&, Iterator const&, Exception const&, Context const& context)
43 {
44 auto& parserContext = x3::get<parser_context_tag>(context);
45 parserContext.m_errorMsg = "Error parsing key values here:";
46 return x3::error_handler_result::rethrow;
47 }
Václav Kubernát0a2a2e82018-05-11 13:59:12 +020048};
Václav Kubernát41378452018-06-06 16:29:40 +020049
Václav Kubernát744f57f2018-06-29 22:46:26 +020050struct node_identifier_class {
51 template <typename T, typename Iterator, typename Context>
52 void on_success(Iterator const&, Iterator const&, T&, Context const& context)
53 {
54 auto& parserContext = x3::get<parser_context_tag>(context);
55
56 if (!parserContext.m_topLevelModulePresent) {
57 if (parserContext.m_errorMsg.empty())
58 parserContext.m_errorMsg = "You have to specify a top level module.";
59 _pass(context) = false;
60 }
61 }
62};
63
Václav Kubernát89728d82018-09-13 16:28:28 +020064struct key_identifier_class;
65
Václav Kubernát744f57f2018-06-29 22:46:26 +020066struct module_identifier_class;
Václav Kubernát0a2a2e82018-05-11 13:59:12 +020067
68struct listPrefix_class {
69 template <typename T, typename Iterator, typename Context>
70 void on_success(Iterator const&, Iterator const&, T& ast, Context const& context)
71 {
72 auto& parserContext = x3::get<parser_context_tag>(context);
Václav Kubernát48fc3832018-05-28 14:21:22 +020073 const Schema& schema = parserContext.m_schema;
Václav Kubernát0a2a2e82018-05-11 13:59:12 +020074
Václav Kubernát744f57f2018-06-29 22:46:26 +020075 if (schema.isList(parserContext.m_curPath, {parserContext.m_curModule, ast})) {
Václav Kubernát0a2a2e82018-05-11 13:59:12 +020076 parserContext.m_tmpListName = ast;
77 } else {
78 _pass(context) = false;
79 }
80 }
81};
82
83struct listSuffix_class {
84 template <typename T, typename Iterator, typename Context>
85 void on_success(Iterator const&, Iterator const&, T& ast, Context const& context)
86 {
87 auto& parserContext = x3::get<parser_context_tag>(context);
Václav Kubernát48fc3832018-05-28 14:21:22 +020088 const Schema& schema = parserContext.m_schema;
Václav Kubernát0a2a2e82018-05-11 13:59:12 +020089
Václav Kubernát744f57f2018-06-29 22:46:26 +020090 const auto& keysNeeded = schema.listKeys(parserContext.m_curPath, {parserContext.m_curModule, parserContext.m_tmpListName});
Václav Kubernát0a2a2e82018-05-11 13:59:12 +020091 std::set<std::string> keysSupplied;
92 for (const auto& it : ast)
93 keysSupplied.insert(it.first);
94
95 if (keysNeeded != keysSupplied) {
96 parserContext.m_errorMsg = "Not enough keys for " + parserContext.m_tmpListName + ". " +
97 "These keys were not supplied:";
98 std::set<std::string> missingKeys;
99 std::set_difference(keysNeeded.begin(), keysNeeded.end(),
100 keysSupplied.begin(), keysSupplied.end(),
101 std::inserter(missingKeys, missingKeys.end()));
102
103 for (const auto& it : missingKeys)
104 parserContext.m_errorMsg += " " + it;
105 parserContext.m_errorMsg += ".";
106
107 _pass(context) = false;
108 }
109 }
Václav Kubernát41378452018-06-06 16:29:40 +0200110
111 template <typename Iterator, typename Exception, typename Context>
112 x3::error_handler_result on_error(Iterator&, Iterator const&, Exception const&, Context const& context)
113 {
114 auto& parserContext = x3::get<parser_context_tag>(context);
115 if (parserContext.m_errorMsg.empty())
116 parserContext.m_errorMsg = "Expecting ']' here:";
117 return x3::error_handler_result::rethrow;
Václav Kubernát41378452018-06-06 16:29:40 +0200118 }
Václav Kubernát0a2a2e82018-05-11 13:59:12 +0200119};
120struct listElement_class {
Václav Kubernát0a2a2e82018-05-11 13:59:12 +0200121 template <typename Iterator, typename Exception, typename Context>
Václav Kubernát41378452018-06-06 16:29:40 +0200122 x3::error_handler_result on_error(Iterator&, Iterator const&, Exception const&, Context const& context)
Václav Kubernát0a2a2e82018-05-11 13:59:12 +0200123 {
124 auto& parserContext = x3::get<parser_context_tag>(context);
Václav Kubernát41378452018-06-06 16:29:40 +0200125 if (parserContext.m_errorMsg.empty()) {
Václav Kubernát0a2a2e82018-05-11 13:59:12 +0200126 return x3::error_handler_result::fail;
Václav Kubernát41378452018-06-06 16:29:40 +0200127 } else {
128 return x3::error_handler_result::rethrow;
129 }
Václav Kubernát0a2a2e82018-05-11 13:59:12 +0200130 }
131};
Václav Kubernát2eaceb82018-10-08 19:56:30 +0200132struct list_class {
133 template <typename T, typename Iterator, typename Context>
134 void on_success(Iterator const&, Iterator const&, T& ast, Context const& context)
135 {
136 auto& parserContext = x3::get<parser_context_tag>(context);
137 const Schema& schema = parserContext.m_schema;
Václav Kubernát0a2a2e82018-05-11 13:59:12 +0200138
Václav Kubernát2eaceb82018-10-08 19:56:30 +0200139 if (!schema.isList(parserContext.m_curPath, {parserContext.m_curModule, ast.m_name})) {
140 _pass(context) = false;
141 }
142 }
143};
Václav Kubernát60d6f292018-05-25 09:45:32 +0200144struct nodeup_class {
145 template <typename T, typename Iterator, typename Context>
146 void on_success(Iterator const&, Iterator const&, T&, Context const& context)
147 {
148 auto& parserContext = x3::get<parser_context_tag>(context);
149
Václav Kubernát744f57f2018-06-29 22:46:26 +0200150 if (parserContext.m_curPath.m_nodes.empty())
Václav Kubernát60d6f292018-05-25 09:45:32 +0200151 _pass(context) = false;
Václav Kubernát60d6f292018-05-25 09:45:32 +0200152 }
153};
154
Václav Kubernát0a2a2e82018-05-11 13:59:12 +0200155struct container_class {
156 template <typename T, typename Iterator, typename Context>
157 void on_success(Iterator const&, Iterator const&, T& ast, Context const& context)
158 {
159 auto& parserContext = x3::get<parser_context_tag>(context);
Václav Kubernát48fc3832018-05-28 14:21:22 +0200160 const auto& schema = parserContext.m_schema;
Václav Kubernát0a2a2e82018-05-11 13:59:12 +0200161
Václav Kubernát744f57f2018-06-29 22:46:26 +0200162 if (!schema.isContainer(parserContext.m_curPath, {parserContext.m_curModule, ast.m_name}))
Václav Kubernát0a2a2e82018-05-11 13:59:12 +0200163 _pass(context) = false;
Václav Kubernát0a2a2e82018-05-11 13:59:12 +0200164 }
165};
166
Václav Kubernát07204242018-06-04 18:12:09 +0200167struct leaf_class {
168 template <typename T, typename Iterator, typename Context>
169 void on_success(Iterator const&, Iterator const&, T& ast, Context const& context)
170 {
171 auto& parserContext = x3::get<parser_context_tag>(context);
172 const auto& schema = parserContext.m_schema;
173
Václav Kubernát744f57f2018-06-29 22:46:26 +0200174 if (!schema.isLeaf(parserContext.m_curPath, {parserContext.m_curModule, ast.m_name}))
175 _pass(context) = false;
176 }
177};
178
Václav Kubernát744f57f2018-06-29 22:46:26 +0200179struct module_class {
180 template <typename T, typename Iterator, typename Context>
181 void on_success(Iterator const&, Iterator const&, T& ast, Context const& context)
182 {
183 auto& parserContext = x3::get<parser_context_tag>(context);
184 const auto& schema = parserContext.m_schema;
185
186 if (schema.isModule(parserContext.m_curPath, ast.m_name)) {
187 parserContext.m_curModule = ast.m_name;
188 parserContext.m_topLevelModulePresent = true;
Václav Kubernát07204242018-06-04 18:12:09 +0200189 } else {
Václav Kubernát744f57f2018-06-29 22:46:26 +0200190 parserContext.m_errorMsg = "Invalid module name.";
Václav Kubernát07204242018-06-04 18:12:09 +0200191 _pass(context) = false;
192 }
193 }
194};
195
Václav Kubernát2eaceb82018-10-08 19:56:30 +0200196struct schemaNode_class {
Václav Kubernát0a2a2e82018-05-11 13:59:12 +0200197 template <typename T, typename Iterator, typename Context>
Václav Kubernát744f57f2018-06-29 22:46:26 +0200198 void on_success(Iterator const&, Iterator const&, T& ast, Context const& context)
Václav Kubernát0a2a2e82018-05-11 13:59:12 +0200199 {
Václav Kubernát744f57f2018-06-29 22:46:26 +0200200 auto& parserContext = x3::get<parser_context_tag>(context);
201 if (ast.m_suffix.type() == typeid(nodeup_)) {
202 parserContext.m_curPath.m_nodes.pop_back();
203 if (parserContext.m_curPath.m_nodes.empty())
204 parserContext.m_topLevelModulePresent = false;
205 } else {
206 parserContext.m_curPath.m_nodes.push_back(ast);
207 parserContext.m_curModule = boost::none;
208 }
Václav Kubernát0a2a2e82018-05-11 13:59:12 +0200209 }
Václav Kubernát744f57f2018-06-29 22:46:26 +0200210};
Václav Kubernát07204242018-06-04 18:12:09 +0200211
Václav Kubernát39ae9592019-02-05 17:35:16 +0100212struct dataNodeList_class {
213 template <typename T, typename Iterator, typename Context>
214 void on_success(Iterator const&, Iterator const&, T& ast, Context const& context)
215 {
216 auto& parserContext = x3::get<parser_context_tag>(context);
217 parserContext.m_curPath.m_nodes.push_back(dataNodeToSchemaNode(ast));
218 }
219};
Václav Kubernát5c75b252018-10-10 18:33:47 +0200220
Václav Kubernát2eaceb82018-10-08 19:56:30 +0200221struct dataNode_class {
222 template <typename T, typename Iterator, typename Context>
223 void on_success(Iterator const&, Iterator const&, T& ast, Context const& context)
224 {
225 auto& parserContext = x3::get<parser_context_tag>(context);
226 if (ast.m_suffix.type() == typeid(nodeup_)) {
227 parserContext.m_curPath.m_nodes.pop_back();
228 if (parserContext.m_curPath.m_nodes.empty())
229 parserContext.m_topLevelModulePresent = false;
230 } else {
231 parserContext.m_curPath.m_nodes.push_back(dataNodeToSchemaNode(ast));
232 parserContext.m_curModule = boost::none;
233 }
234 }
235};
236
Václav Kubernát37171a12018-08-31 17:01:48 +0200237struct absoluteStart_class {
238 template <typename T, typename Iterator, typename Context>
239 void on_success(Iterator const&, Iterator const&, T&, Context const& context)
240 {
241 auto& parserContext = x3::get<parser_context_tag>(context);
242 parserContext.m_curPath.m_nodes.clear();
Václav Kubernátb9621052019-03-18 18:27:49 +0100243 parserContext.m_topLevelModulePresent = false;
Václav Kubernát37171a12018-08-31 17:01:48 +0200244 }
245};
246
Václav Kubernát5c75b252018-10-10 18:33:47 +0200247struct dataNodesListEnd_class;
248
249struct dataPathListEnd_class;
250
Václav Kubernát2eaceb82018-10-08 19:56:30 +0200251struct dataPath_class {
252 template <typename Iterator, typename Exception, typename Context>
253 x3::error_handler_result on_error(Iterator&, Iterator const&, Exception const&, Context const& context)
254 {
255 auto& parserContext = x3::get<parser_context_tag>(context);
256 if (parserContext.m_errorMsg.empty()) {
257 parserContext.m_errorMsg = "Expected path.";
258 return x3::error_handler_result::fail;
259 } else {
260 return x3::error_handler_result::rethrow;
261 }
262 }
263};
264
265struct schemaPath_class {
Václav Kubernát07204242018-06-04 18:12:09 +0200266 template <typename Iterator, typename Exception, typename Context>
Václav Kubernát41378452018-06-06 16:29:40 +0200267 x3::error_handler_result on_error(Iterator&, Iterator const&, Exception const&, Context const& context)
Václav Kubernát07204242018-06-04 18:12:09 +0200268 {
269 auto& parserContext = x3::get<parser_context_tag>(context);
Václav Kubernát41378452018-06-06 16:29:40 +0200270 if (parserContext.m_errorMsg.empty()) {
271 parserContext.m_errorMsg = "Expected path.";
Václav Kubernát07204242018-06-04 18:12:09 +0200272 return x3::error_handler_result::fail;
Václav Kubernát41378452018-06-06 16:29:40 +0200273 } else {
274 return x3::error_handler_result::rethrow;
275 }
Václav Kubernát07204242018-06-04 18:12:09 +0200276 }
277};
278
Václav Kubernát6d791432018-10-25 16:00:35 +0200279struct discard_class;
Václav Kubernát0a2a2e82018-05-11 13:59:12 +0200280
Václav Kubernát11afac72018-07-18 14:59:53 +0200281struct ls_class;
282
Václav Kubernát744f57f2018-06-29 22:46:26 +0200283struct cd_class {
Václav Kubernát0a2a2e82018-05-11 13:59:12 +0200284 template <typename Iterator, typename Exception, typename Context>
285 x3::error_handler_result on_error(Iterator&, Iterator const&, Exception const& x, Context const& context)
286 {
287 auto& parserContext = x3::get<parser_context_tag>(context);
Václav Kubernát41378452018-06-06 16:29:40 +0200288 if (parserContext.m_errorMsg.empty())
289 parserContext.m_errorMsg = "Expected " + x.which() + " here:";
290 return x3::error_handler_result::rethrow;
Václav Kubernát0a2a2e82018-05-11 13:59:12 +0200291 }
292};
Václav Kubernátb61336d2018-05-28 17:35:03 +0200293
Václav Kubernát6797df02019-03-18 20:21:50 +0100294struct presenceContainerPath_class {
Václav Kubernátb61336d2018-05-28 17:35:03 +0200295 template <typename T, typename Iterator, typename Context>
296 void on_success(Iterator const&, Iterator const&, T& ast, Context const& context)
297 {
298 auto& parserContext = x3::get<parser_context_tag>(context);
299 const auto& schema = parserContext.m_schema;
300 try {
Václav Kubernát744f57f2018-06-29 22:46:26 +0200301 boost::optional<std::string> module;
Václav Kubernát6797df02019-03-18 20:21:50 +0100302 if (ast.m_nodes.back().m_prefix)
303 module = ast.m_nodes.back().m_prefix.value().m_name;
304 container_ cont = boost::get<container_>(ast.m_nodes.back().m_suffix);
Václav Kubernát2eaceb82018-10-08 19:56:30 +0200305 schemaPath_ location = pathWithoutLastNode(parserContext.m_curPath);
Václav Kubernátb61336d2018-05-28 17:35:03 +0200306
Václav Kubernát744f57f2018-06-29 22:46:26 +0200307 if (!schema.isPresenceContainer(location, {module, cont.m_name})) {
Václav Kubernát41378452018-06-06 16:29:40 +0200308 parserContext.m_errorMsg = "This container is not a presence container.";
Václav Kubernátb61336d2018-05-28 17:35:03 +0200309 _pass(context) = false;
Václav Kubernátb61336d2018-05-28 17:35:03 +0200310 }
311 } catch (boost::bad_get&) {
Václav Kubernát41378452018-06-06 16:29:40 +0200312 parserContext.m_errorMsg = "This is not a container.";
Václav Kubernátb61336d2018-05-28 17:35:03 +0200313 _pass(context) = false;
Václav Kubernátb61336d2018-05-28 17:35:03 +0200314 }
315 }
Václav Kubernát6797df02019-03-18 20:21:50 +0100316};
Václav Kubernátb61336d2018-05-28 17:35:03 +0200317
Václav Kubernátf5f64f02019-03-19 17:15:47 +0100318struct listInstancePath_class {
319 template <typename T, typename Iterator, typename Context>
320 void on_success(Iterator const&, Iterator const&, T& ast, Context const& context)
321 {
322 auto& parserContext = x3::get<parser_context_tag>(context);
323 if (ast.m_nodes.back().m_suffix.type() != typeid(listElement_)) {
324 parserContext.m_errorMsg = "This is not a list instance.";
325 _pass(context) = false;
326 }
327 }
328};
329
Václav Kubernát8028f942019-09-25 16:03:23 +0200330struct space_separator_class {
331 template <typename T, typename Iterator, typename Context>
332 void on_success(Iterator const&, Iterator const&, T&, Context const& context)
333 {
334 auto& parserContext = x3::get<parser_context_tag>(context);
335 parserContext.m_suggestions.clear();
336 }
337};
338
Václav Kubernát6797df02019-03-18 20:21:50 +0100339struct create_class {
Václav Kubernátb61336d2018-05-28 17:35:03 +0200340 template <typename Iterator, typename Exception, typename Context>
Václav Kubernát41378452018-06-06 16:29:40 +0200341 x3::error_handler_result on_error(Iterator&, Iterator const&, Exception const&, Context const& context)
Václav Kubernátb61336d2018-05-28 17:35:03 +0200342 {
343 auto& parserContext = x3::get<parser_context_tag>(context);
Václav Kubernát41378452018-06-06 16:29:40 +0200344 if (parserContext.m_errorMsg.empty())
345 parserContext.m_errorMsg = "Couldn't parse create/delete command.";
346 return x3::error_handler_result::rethrow;
Václav Kubernátb61336d2018-05-28 17:35:03 +0200347 }
348};
349
Václav Kubernát6797df02019-03-18 20:21:50 +0100350struct delete_class {
351 template <typename Iterator, typename Exception, typename Context>
352 x3::error_handler_result on_error(Iterator&, Iterator const&, Exception const&, Context const& context)
353 {
354 auto& parserContext = x3::get<parser_context_tag>(context);
355 if (parserContext.m_errorMsg.empty())
356 parserContext.m_errorMsg = "Couldn't parse create/delete command.";
357 return x3::error_handler_result::rethrow;
358 }
Václav Kubernátb61336d2018-05-28 17:35:03 +0200359};
360
Václav Kubernát0b0272f2018-06-13 14:13:08 +0200361struct leaf_path_class {
362 template <typename T, typename Iterator, typename Context>
363 void on_success(Iterator const&, Iterator const&, T& ast, Context const& context)
364 {
365 auto& parserContext = x3::get<parser_context_tag>(context);
366 try {
Václav Kubernát744f57f2018-06-29 22:46:26 +0200367 auto leaf = boost::get<leaf_>(ast.m_nodes.back().m_suffix);
Václav Kubernát0b0272f2018-06-13 14:13:08 +0200368 } catch (boost::bad_get&) {
369 parserContext.m_errorMsg = "This is not a path to leaf.";
370 _pass(context) = false;
371 }
372 }
373};
374
Václav Kubernáteeb38842019-03-20 19:46:05 +0100375// This handler only checks if the module exists
376// It doesn't set any ParserContext flags (except the error message)
377struct data_module_prefix_class {
378 template <typename T, typename Iterator, typename Context>
379 void on_success(Iterator const&, Iterator const&, T& ast, Context const& context)
380 {
381 auto& parserContext = x3::get<parser_context_tag>(context);
382 const auto& schema = parserContext.m_schema;
383
384 if (!schema.isModule(parserContext.m_curPath, ast.m_name)) {
385 parserContext.m_errorMsg = "Invalid module name.";
386 _pass(context) = false;
387 }
388 }
389};
390
Václav Kubernátebca2552018-06-08 19:06:02 +0200391struct leaf_data_class {
Václav Kubernát0b0272f2018-06-13 14:13:08 +0200392 template <typename Iterator, typename Exception, typename Context>
393 x3::error_handler_result on_error(Iterator&, Iterator const&, Exception const&, Context const& context)
394 {
395 auto& parserContext = x3::get<parser_context_tag>(context);
396 auto& schema = parserContext.m_schema;
397 if (parserContext.m_errorMsg.empty()) {
Václav Kubernát744f57f2018-06-29 22:46:26 +0200398 leaf_ leaf = boost::get<leaf_>(parserContext.m_curPath.m_nodes.back().m_suffix);
Václav Kubernát2eaceb82018-10-08 19:56:30 +0200399 schemaPath_ location = pathWithoutLastNode(parserContext.m_curPath);
Václav Kubernáteeb38842019-03-20 19:46:05 +0100400 boost::optional<std::string> module;
401 if (parserContext.m_curPath.m_nodes.back().m_prefix)
402 module = parserContext.m_curPath.m_nodes.back().m_prefix.value().m_name;
403 parserContext.m_errorMsg = "Expected " + leafDataTypeToString(schema.leafType(location, {module, leaf.m_name})) + " here:";
Václav Kubernát0b0272f2018-06-13 14:13:08 +0200404 return x3::error_handler_result::fail;
405 }
406 return x3::error_handler_result::rethrow;
407 }
Václav Kubernátebca2552018-06-08 19:06:02 +0200408};
409
Ivona Oboňová88c78ca2019-07-02 18:40:07 +0200410template<yang::LeafDataTypes TYPE>
Václav Kubernátebca2552018-06-08 19:06:02 +0200411struct leaf_data_base_class {
412 yang::LeafDataTypes m_type;
413
Ivona Oboňová88c78ca2019-07-02 18:40:07 +0200414 leaf_data_base_class()
415 : m_type(TYPE)
Václav Kubernátebca2552018-06-08 19:06:02 +0200416 {
417 }
418
419 template <typename T, typename Iterator, typename Context>
420 void on_success(Iterator const&, Iterator const&, T&, Context const& context)
421 {
422 auto& parserContext = x3::get<parser_context_tag>(context);
423 auto& schema = parserContext.m_schema;
Václav Kubernát744f57f2018-06-29 22:46:26 +0200424 boost::optional<std::string> module;
425 if (parserContext.m_curPath.m_nodes.back().m_prefix)
426 module = parserContext.m_curPath.m_nodes.back().m_prefix.value().m_name;
Václav Kubernátebca2552018-06-08 19:06:02 +0200427
Václav Kubernát744f57f2018-06-29 22:46:26 +0200428 leaf_ leaf = boost::get<leaf_>(parserContext.m_curPath.m_nodes.back().m_suffix);
Václav Kubernát2eaceb82018-10-08 19:56:30 +0200429 schemaPath_ location = pathWithoutLastNode(parserContext.m_curPath);
Václav Kubernátebca2552018-06-08 19:06:02 +0200430
Václav Kubernát6a8d1d92019-04-24 20:30:36 +0200431 auto type = schema.leafType(location, {module, leaf.m_name});
432 if (type == yang::LeafDataTypes::LeafRef) {
433 type = schema.leafrefBase(location, {module, leaf.m_name});
434 }
435 if (type != m_type) {
Václav Kubernátebca2552018-06-08 19:06:02 +0200436 _pass(context) = false;
437 }
438 }
439};
440
Ivona Oboňová88c78ca2019-07-02 18:40:07 +0200441struct leaf_data_binary_data_class;
442
443struct leaf_data_enum_class : leaf_data_base_class<yang::LeafDataTypes::Enum> {
444 using leaf_data_base_class::leaf_data_base_class;
Václav Kubernátebca2552018-06-08 19:06:02 +0200445
446 template <typename T, typename Iterator, typename Context>
447 void on_success(Iterator const& start, Iterator const& end, T& ast, Context const& context)
448 {
449 leaf_data_base_class::on_success(start, end, ast, context);
Václav Kubernáteeb38842019-03-20 19:46:05 +0100450 // Base class on_success cannot return for us, so we check if it failed the parser.
451 if (_pass(context) == false)
452 return;
Václav Kubernátebca2552018-06-08 19:06:02 +0200453 auto& parserContext = x3::get<parser_context_tag>(context);
454 auto& schema = parserContext.m_schema;
Václav Kubernát744f57f2018-06-29 22:46:26 +0200455 boost::optional<std::string> module;
456 if (parserContext.m_curPath.m_nodes.back().m_prefix)
457 module = parserContext.m_curPath.m_nodes.back().m_prefix.value().m_name;
Václav Kubernátebca2552018-06-08 19:06:02 +0200458
Václav Kubernát744f57f2018-06-29 22:46:26 +0200459 leaf_ leaf = boost::get<leaf_>(parserContext.m_curPath.m_nodes.back().m_suffix);
Václav Kubernát2eaceb82018-10-08 19:56:30 +0200460 schemaPath_ location = pathWithoutLastNode(parserContext.m_curPath);
Václav Kubernátebca2552018-06-08 19:06:02 +0200461
Václav Kubernát744f57f2018-06-29 22:46:26 +0200462 if (!schema.leafEnumHasValue(location, {module, leaf.m_name}, ast.m_value)) {
Václav Kubernátebca2552018-06-08 19:06:02 +0200463 _pass(context) = false;
464 }
465 }
466};
467
Václav Kubernáteeb38842019-03-20 19:46:05 +0100468struct leaf_data_identityRef_data_class;
469
Ivona Oboňová88c78ca2019-07-02 18:40:07 +0200470struct leaf_data_identityRef_class : leaf_data_base_class<yang::LeafDataTypes::IdentityRef> {
471 using leaf_data_base_class::leaf_data_base_class;
Václav Kubernáteeb38842019-03-20 19:46:05 +0100472
473 template <typename T, typename Iterator, typename Context>
474 void on_success(Iterator const& start, Iterator const& end, T& ast, Context const& context)
475 {
476 // FIXME: can I reuse leaf_data_enum_class somehow..?
477 leaf_data_base_class::on_success(start, end, ast, context);
478 // Base class on_success cannot return for us, so we check if it failed the parser.
479 if (_pass(context) == false)
480 return;
481 auto& parserContext = x3::get<parser_context_tag>(context);
482 auto& schema = parserContext.m_schema;
483 boost::optional<std::string> module;
484 if (parserContext.m_curPath.m_nodes.back().m_prefix)
485 module = parserContext.m_curPath.m_nodes.back().m_prefix.value().m_name;
486
487 leaf_ leaf = boost::get<leaf_>(parserContext.m_curPath.m_nodes.back().m_suffix);
488 schemaPath_ location = pathWithoutLastNode(parserContext.m_curPath);
489
490 ModuleValuePair pair;
491 if (ast.m_prefix) {
492 pair.first = ast.m_prefix.get().m_name;
493 }
494 pair.second = ast.m_value;
495
496 if (!schema.leafIdentityIsValid(location, {module, leaf.m_name}, pair)) {
497 _pass(context) = false;
498 }
499 }
500};
501
Václav Kubernát07204242018-06-04 18:12:09 +0200502struct set_class {
Václav Kubernát07204242018-06-04 18:12:09 +0200503 template <typename Iterator, typename Exception, typename Context>
504 x3::error_handler_result on_error(Iterator&, Iterator const&, Exception const& x, Context const& context)
505 {
506 auto& parserContext = x3::get<parser_context_tag>(context);
Václav Kubernát41378452018-06-06 16:29:40 +0200507 if (parserContext.m_errorMsg.empty())
508 parserContext.m_errorMsg = "Expected " + x.which() + " here:";
509 return x3::error_handler_result::rethrow;
Václav Kubernát07204242018-06-04 18:12:09 +0200510 }
511};
512
Václav Kubernát812ee282018-08-30 17:10:03 +0200513struct commit_class;
514
Václav Kubernát054cc992019-02-21 14:23:52 +0100515struct help_class;
516
Václav Kubernátb6ff0b62018-08-30 16:14:53 +0200517struct get_class;
518
Václav Kubernátb61336d2018-05-28 17:35:03 +0200519struct command_class {
520 template <typename Iterator, typename Exception, typename Context>
521 x3::error_handler_result on_error(Iterator&, Iterator const&, Exception const& x, Context const& context)
522 {
523 auto& parserContext = x3::get<parser_context_tag>(context);
524 auto& error_handler = x3::get<x3::error_handler_tag>(context).get();
Václav Kubernát41378452018-06-06 16:29:40 +0200525 if (parserContext.m_errorMsg.empty()) {
526 parserContext.m_errorMsg = "Unknown command.";
527 }
528 error_handler(x.where(), parserContext.m_errorMsg);
Václav Kubernátb61336d2018-05-28 17:35:03 +0200529 return x3::error_handler_result::fail;
530 }
531};
Václav Kubernát5c75b252018-10-10 18:33:47 +0200532
Václav Kubernát4108e0d2018-10-29 13:32:22 +0100533struct initializePath_class {
Václav Kubernát5c75b252018-10-10 18:33:47 +0200534 template <typename T, typename Iterator, typename Context>
535 void on_success(Iterator const&, Iterator const&, T&, Context const& context)
536 {
537 auto& parserContext = x3::get<parser_context_tag>(context);
538 parserContext.m_curPath = parserContext.m_curPathOrig;
539 parserContext.m_tmpListKeys.clear();
540 parserContext.m_tmpListName.clear();
Václav Kubernát4108e0d2018-10-29 13:32:22 +0100541 parserContext.m_suggestions.clear();
Václav Kubernát5c75b252018-10-10 18:33:47 +0200542 if (!parserContext.m_curPath.m_nodes.empty() && parserContext.m_curPath.m_nodes.at(0).m_prefix)
543 parserContext.m_topLevelModulePresent = true;
544 else
545 parserContext.m_topLevelModulePresent = false;
546 }
547};
Václav Kubernátd6fd2492018-11-19 15:11:16 +0100548
549struct trailingSlash_class;
Václav Kubernát4108e0d2018-10-29 13:32:22 +0100550
551struct createPathSuggestions_class {
552 template <typename T, typename Iterator, typename Context>
553 void on_success(Iterator const& begin, Iterator const&, T&, Context const& context)
554 {
555 auto& parserContext = x3::get<parser_context_tag>(context);
556 const auto& schema = parserContext.m_schema;
557
558 parserContext.m_completionIterator = begin;
559 parserContext.m_suggestions = schema.childNodes(parserContext.m_curPath, Recursion::NonRecursive);
560 }
561};
Václav Kubernát329c6c32019-02-06 16:41:53 +0100562
563std::set<std::string> generateMissingKeyCompletionSet(std::set<std::string> keysNeeded, std::set<std::string> currentSet);
564
565struct createKeySuggestions_class {
566 template <typename T, typename Iterator, typename Context>
567 void on_success(Iterator const& begin, Iterator const&, T&, Context const& context)
568 {
569 auto& parserContext = x3::get<parser_context_tag>(context);
570 const auto& schema = parserContext.m_schema;
571
572 parserContext.m_completionIterator = begin;
573
574 const auto& keysNeeded = schema.listKeys(parserContext.m_curPath, {parserContext.m_curModule, parserContext.m_tmpListName});
575 parserContext.m_suggestions = generateMissingKeyCompletionSet(keysNeeded, parserContext.m_tmpListKeys);
576 }
577};
578
579struct suggestKeysEnd_class {
580 template <typename T, typename Iterator, typename Context>
581 void on_success(Iterator const& begin, Iterator const&, T&, Context const& context)
582 {
583 auto& parserContext = x3::get<parser_context_tag>(context);
584 const auto& schema = parserContext.m_schema;
585
586 parserContext.m_completionIterator = begin;
587 const auto& keysNeeded = schema.listKeys(parserContext.m_curPath, {parserContext.m_curModule, parserContext.m_tmpListName});
588 if (generateMissingKeyCompletionSet(keysNeeded, parserContext.m_tmpListKeys).empty()) {
589 parserContext.m_suggestions = {"]/"};
590 } else {
Václav Kubernát4c325482019-04-11 17:51:55 +0200591 parserContext.m_suggestions = {"]["};
Václav Kubernát329c6c32019-02-06 16:41:53 +0100592 }
593 }
594};
Václav Kubernát57272422019-02-08 12:48:24 +0100595
Václav Kubernát4c325482019-04-11 17:51:55 +0200596struct suggestKeysStart_class {
597 template <typename T, typename Iterator, typename Context>
598 void on_success(Iterator const&, Iterator const&, T&, Context const& context)
599 {
600 auto& parserContext = x3::get<parser_context_tag>(context);
601
602 parserContext.m_completionSuffix = "[";
603 }
604};
605
Václav Kubernát57272422019-02-08 12:48:24 +0100606struct commandNamesVisitor {
607 template <typename T>
608 auto operator()(boost::type<T>)
609 {
610 return T::name;
611 }
612};
613
614struct createCommandSuggestions_class {
615 template <typename T, typename Iterator, typename Context>
616 void on_success(Iterator const& begin, Iterator const&, T&, Context const& context)
617 {
618 auto& parserContext = x3::get<parser_context_tag>(context);
619 parserContext.m_completionIterator = begin;
620
621 parserContext.m_suggestions.clear();
622 boost::mpl::for_each<CommandTypes, boost::type<boost::mpl::_>>([&parserContext](auto cmd) {
623 parserContext.m_suggestions.emplace(commandNamesVisitor()(cmd));
624 });
625 }
626};
Václav Kubernátac035d62019-02-18 10:59:08 +0100627
628struct completing_class {
629 template <typename T, typename Iterator, typename Context>
630 void on_success(Iterator const&, Iterator const&, T&, Context const& context)
631 {
632 auto& parserContext = x3::get<parser_context_tag>(context);
633
634 if (!parserContext.m_completing)
635 _pass(context) = false;
636 }
637};
Václav Kubernát989b5de2019-02-20 16:28:35 +0100638
639struct createEnumSuggestions_class {
640 template <typename T, typename Iterator, typename Context>
641 void on_success(Iterator const& begin, Iterator const&, T&, Context const& context)
642 {
643 auto& parserContext = x3::get<parser_context_tag>(context);
644 parserContext.m_completionIterator = begin;
645 const Schema& schema = parserContext.m_schema;
646
647 boost::optional<std::string> module;
648 if (parserContext.m_curPath.m_nodes.back().m_prefix)
649 module = parserContext.m_curPath.m_nodes.back().m_prefix.value().m_name;
650
651 leaf_ leaf = boost::get<leaf_>(parserContext.m_curPath.m_nodes.back().m_suffix);
652 schemaPath_ location = pathWithoutLastNode(parserContext.m_curPath);
653
Václav Kubernáteeb38842019-03-20 19:46:05 +0100654 // Only generate completions if the type is enum so that we don't
655 // overwrite some other completions.
656 if (schema.leafType(location, {module, leaf.m_name}) == yang::LeafDataTypes::Enum)
657 parserContext.m_suggestions = schema.enumValues(location, {module, leaf.m_name});
658 }
659};
660
661// FIXME: can I reuse createEnumSuggestions?
662struct createIdentitySuggestions_class {
663 template <typename T, typename Iterator, typename Context>
664 void on_success(Iterator const& begin, Iterator const&, T&, Context const& context)
665 {
666 auto& parserContext = x3::get<parser_context_tag>(context);
667 parserContext.m_completionIterator = begin;
668 const Schema& schema = parserContext.m_schema;
669
670 boost::optional<std::string> module;
671 if (parserContext.m_curPath.m_nodes.back().m_prefix)
672 module = parserContext.m_curPath.m_nodes.back().m_prefix.value().m_name;
673
674 leaf_ leaf = boost::get<leaf_>(parserContext.m_curPath.m_nodes.back().m_suffix);
675 schemaPath_ location = pathWithoutLastNode(parserContext.m_curPath);
676
677 // Only generate completions if the type is identityref so that we
678 // don't overwrite some other completions.
679 if (schema.leafType(location, {module, leaf.m_name}) == yang::LeafDataTypes::IdentityRef)
680 parserContext.m_suggestions = schema.validIdentities(location, {module, leaf.m_name}, Prefixes::WhenNeeded);
Václav Kubernát989b5de2019-02-20 16:28:35 +0100681 }
682};