blob: b9cf883a2854cc28ec1c44b3a3b894df560b0bb9 [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át4294a852020-02-14 15:07:14 +010017#include "parser_context.hpp"
Václav Kubernát48fc3832018-05-28 14:21:22 +020018#include "schema.hpp"
Václav Kubernátebca2552018-06-08 19:06:02 +020019#include "utils.hpp"
Václav Kubernát329c6c32019-02-06 16:41:53 +010020namespace x3 = boost::spirit::x3;
21
22struct parser_context_tag;
Václav Kubernát0a2a2e82018-05-11 13:59:12 +020023
Václav Kubernát0a2a2e82018-05-11 13:59:12 +020024struct keyValue_class {
25 template <typename T, typename Iterator, typename Context>
26 void on_success(Iterator const&, Iterator const&, T& ast, Context const& context)
27 {
28 auto& parserContext = x3::get<parser_context_tag>(context);
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át41378452018-06-06 16:29:40 +020033 } else {
Václav Kubernát43908fb2020-01-02 19:05:51 +010034 parserContext.m_tmpListKeys.insert({ast.first, ast.second});
Václav Kubernát0a2a2e82018-05-11 13:59:12 +020035 }
36 }
Václav Kubernát41378452018-06-06 16:29:40 +020037
38 template <typename Iterator, typename Exception, typename Context>
39 x3::error_handler_result on_error(Iterator&, Iterator const&, Exception const&, Context const& context)
40 {
41 auto& parserContext = x3::get<parser_context_tag>(context);
42 parserContext.m_errorMsg = "Error parsing key values here:";
43 return x3::error_handler_result::rethrow;
44 }
Václav Kubernát0a2a2e82018-05-11 13:59:12 +020045};
Václav Kubernát41378452018-06-06 16:29:40 +020046
Václav Kubernát744f57f2018-06-29 22:46:26 +020047struct node_identifier_class {
48 template <typename T, typename Iterator, typename Context>
49 void on_success(Iterator const&, Iterator const&, T&, Context const& context)
50 {
51 auto& parserContext = x3::get<parser_context_tag>(context);
52
53 if (!parserContext.m_topLevelModulePresent) {
54 if (parserContext.m_errorMsg.empty())
55 parserContext.m_errorMsg = "You have to specify a top level module.";
56 _pass(context) = false;
57 }
58 }
59};
60
Václav Kubernát7707cae2020-01-16 12:04:53 +010061struct key_identifier_class {
62 template <typename T, typename Iterator, typename Context>
63 void on_success(Iterator const&, Iterator const&, T& ast, Context const& context)
64 {
65 auto& parserContext = x3::get<parser_context_tag>(context);
66 const Schema& schema = parserContext.m_schema;
67 schemaPath_ location = parserContext.currentSchemaPath();
68 ModuleNodePair list{parserContext.m_curModule, parserContext.m_tmpListName};
69
70 if (schema.listHasKey(location, list, ast)) {
71 schemaNode_ listNode;
Václav Kubernát43908fb2020-01-02 19:05:51 +010072 listNode.m_prefix = parserContext.m_curModule.flat_map([] (auto mod) { return boost::optional<module_>{{mod}}; });;
Václav Kubernát7707cae2020-01-16 12:04:53 +010073 listNode.m_suffix = list_{parserContext.m_tmpListName};
74 location.m_nodes.push_back(listNode);
75 parserContext.m_tmpListKeyLeafPath.m_location = location;
Václav Kubernát43908fb2020-01-02 19:05:51 +010076 parserContext.m_tmpListKeyLeafPath.m_node = { parserContext.m_curModule, ast };
Václav Kubernát7707cae2020-01-16 12:04:53 +010077 } else {
78 parserContext.m_errorMsg = parserContext.m_tmpListName + " is not indexed by \"" + ast + "\".";
79 _pass(context) = false;
80 }
81 }
82};
Václav Kubernát89728d82018-09-13 16:28:28 +020083
Václav Kubernát744f57f2018-06-29 22:46:26 +020084struct module_identifier_class;
Václav Kubernát0a2a2e82018-05-11 13:59:12 +020085
Václav Kubernát0a2a2e82018-05-11 13:59:12 +020086struct listSuffix_class {
87 template <typename T, typename Iterator, typename Context>
88 void on_success(Iterator const&, Iterator const&, T& ast, Context const& context)
89 {
90 auto& parserContext = x3::get<parser_context_tag>(context);
Václav Kubernát48fc3832018-05-28 14:21:22 +020091 const Schema& schema = parserContext.m_schema;
Václav Kubernát0a2a2e82018-05-11 13:59:12 +020092
Václav Kubernát72749c62020-01-03 16:47:34 +010093 const auto& keysNeeded = schema.listKeys(parserContext.currentSchemaPath(), {parserContext.m_curModule, parserContext.m_tmpListName});
Václav Kubernát0a2a2e82018-05-11 13:59:12 +020094 std::set<std::string> keysSupplied;
95 for (const auto& it : ast)
96 keysSupplied.insert(it.first);
97
98 if (keysNeeded != keysSupplied) {
99 parserContext.m_errorMsg = "Not enough keys for " + parserContext.m_tmpListName + ". " +
100 "These keys were not supplied:";
101 std::set<std::string> missingKeys;
102 std::set_difference(keysNeeded.begin(), keysNeeded.end(),
103 keysSupplied.begin(), keysSupplied.end(),
104 std::inserter(missingKeys, missingKeys.end()));
105
106 for (const auto& it : missingKeys)
107 parserContext.m_errorMsg += " " + it;
108 parserContext.m_errorMsg += ".";
109
110 _pass(context) = false;
111 }
112 }
Václav Kubernát41378452018-06-06 16:29:40 +0200113
114 template <typename Iterator, typename Exception, typename Context>
115 x3::error_handler_result on_error(Iterator&, Iterator const&, Exception const&, Context const& context)
116 {
117 auto& parserContext = x3::get<parser_context_tag>(context);
118 if (parserContext.m_errorMsg.empty())
119 parserContext.m_errorMsg = "Expecting ']' here:";
120 return x3::error_handler_result::rethrow;
Václav Kubernát41378452018-06-06 16:29:40 +0200121 }
Václav Kubernát0a2a2e82018-05-11 13:59:12 +0200122};
Václav Kubernát744f57f2018-06-29 22:46:26 +0200123
Václav Kubernát744f57f2018-06-29 22:46:26 +0200124struct module_class {
125 template <typename T, typename Iterator, typename Context>
126 void on_success(Iterator const&, Iterator const&, T& ast, Context const& context)
127 {
128 auto& parserContext = x3::get<parser_context_tag>(context);
129 const auto& schema = parserContext.m_schema;
130
Václav Kubernát75877de2019-11-20 17:43:02 +0100131 if (schema.isModule(ast.m_name)) {
Václav Kubernát744f57f2018-06-29 22:46:26 +0200132 parserContext.m_curModule = ast.m_name;
133 parserContext.m_topLevelModulePresent = true;
Václav Kubernát07204242018-06-04 18:12:09 +0200134 } else {
Václav Kubernát744f57f2018-06-29 22:46:26 +0200135 parserContext.m_errorMsg = "Invalid module name.";
Václav Kubernát07204242018-06-04 18:12:09 +0200136 _pass(context) = false;
137 }
138 }
139};
140
Václav Kubernát37171a12018-08-31 17:01:48 +0200141struct absoluteStart_class {
142 template <typename T, typename Iterator, typename Context>
143 void on_success(Iterator const&, Iterator const&, T&, Context const& context)
144 {
145 auto& parserContext = x3::get<parser_context_tag>(context);
Václav Kubernát72749c62020-01-03 16:47:34 +0100146 parserContext.clearPath();
Václav Kubernát37171a12018-08-31 17:01:48 +0200147 }
148};
149
Václav Kubernát6d791432018-10-25 16:00:35 +0200150struct discard_class;
Václav Kubernát0a2a2e82018-05-11 13:59:12 +0200151
Václav Kubernát11afac72018-07-18 14:59:53 +0200152struct ls_class;
153
Václav Kubernát744f57f2018-06-29 22:46:26 +0200154struct cd_class {
Václav Kubernát0a2a2e82018-05-11 13:59:12 +0200155 template <typename Iterator, typename Exception, typename Context>
156 x3::error_handler_result on_error(Iterator&, Iterator const&, Exception const& x, Context const& context)
157 {
158 auto& parserContext = x3::get<parser_context_tag>(context);
Václav Kubernát41378452018-06-06 16:29:40 +0200159 if (parserContext.m_errorMsg.empty())
160 parserContext.m_errorMsg = "Expected " + x.which() + " here:";
161 return x3::error_handler_result::rethrow;
Václav Kubernát0a2a2e82018-05-11 13:59:12 +0200162 }
163};
Václav Kubernátb61336d2018-05-28 17:35:03 +0200164
Václav Kubernát6797df02019-03-18 20:21:50 +0100165struct presenceContainerPath_class {
Václav Kubernátb61336d2018-05-28 17:35:03 +0200166 template <typename T, typename Iterator, typename Context>
167 void on_success(Iterator const&, Iterator const&, T& ast, Context const& context)
168 {
169 auto& parserContext = x3::get<parser_context_tag>(context);
170 const auto& schema = parserContext.m_schema;
Václav Kubernát0d42c512020-05-20 21:18:39 +0200171 if (ast.m_nodes.empty()) {
172 parserContext.m_errorMsg = "This container is not a presence container.";
173 _pass(context) = false;
174 return;
175 }
176
Václav Kubernátb61336d2018-05-28 17:35:03 +0200177 try {
Václav Kubernát744f57f2018-06-29 22:46:26 +0200178 boost::optional<std::string> module;
Václav Kubernát6797df02019-03-18 20:21:50 +0100179 if (ast.m_nodes.back().m_prefix)
180 module = ast.m_nodes.back().m_prefix.value().m_name;
181 container_ cont = boost::get<container_>(ast.m_nodes.back().m_suffix);
Václav Kubernát72749c62020-01-03 16:47:34 +0100182 auto location = pathWithoutLastNode(parserContext.currentSchemaPath());
Václav Kubernátb61336d2018-05-28 17:35:03 +0200183
Václav Kubernát744f57f2018-06-29 22:46:26 +0200184 if (!schema.isPresenceContainer(location, {module, cont.m_name})) {
Václav Kubernát41378452018-06-06 16:29:40 +0200185 parserContext.m_errorMsg = "This container is not a presence container.";
Václav Kubernátb61336d2018-05-28 17:35:03 +0200186 _pass(context) = false;
Václav Kubernátb61336d2018-05-28 17:35:03 +0200187 }
188 } catch (boost::bad_get&) {
Václav Kubernát41378452018-06-06 16:29:40 +0200189 parserContext.m_errorMsg = "This is not a container.";
Václav Kubernátb61336d2018-05-28 17:35:03 +0200190 _pass(context) = false;
Václav Kubernátb61336d2018-05-28 17:35:03 +0200191 }
192 }
Václav Kubernát6797df02019-03-18 20:21:50 +0100193};
Václav Kubernátb61336d2018-05-28 17:35:03 +0200194
Václav Kubernátf5f64f02019-03-19 17:15:47 +0100195struct listInstancePath_class {
196 template <typename T, typename Iterator, typename Context>
197 void on_success(Iterator const&, Iterator const&, T& ast, Context const& context)
198 {
199 auto& parserContext = x3::get<parser_context_tag>(context);
Václav Kubernát0d42c512020-05-20 21:18:39 +0200200 if (ast.m_nodes.empty()) {
201 parserContext.m_errorMsg = "This is not a list instance.";
202 _pass(context) = false;
203 return;
204 }
205
Václav Kubernátf5f64f02019-03-19 17:15:47 +0100206 if (ast.m_nodes.back().m_suffix.type() != typeid(listElement_)) {
207 parserContext.m_errorMsg = "This is not a list instance.";
208 _pass(context) = false;
209 }
210 }
211};
212
Václav Kubernát5b8a8f32020-05-20 00:57:22 +0200213struct leafListElementPath_class {
214 template <typename T, typename Iterator, typename Context>
215 void on_success(Iterator const&, Iterator const&, T& ast, Context const& context)
216 {
217 auto& parserContext = x3::get<parser_context_tag>(context);
218 if (ast.m_nodes.empty() || ast.m_nodes.back().m_suffix.type() != typeid(leafListElement_)) {
219 parserContext.m_errorMsg = "This is not a leaf list element.";
220 _pass(context) = false;
221 }
222 }
223};
224
Václav Kubernát8028f942019-09-25 16:03:23 +0200225struct space_separator_class {
226 template <typename T, typename Iterator, typename Context>
227 void on_success(Iterator const&, Iterator const&, T&, Context const& context)
228 {
229 auto& parserContext = x3::get<parser_context_tag>(context);
230 parserContext.m_suggestions.clear();
Václav Kubernát1ed4aa32020-01-23 13:13:28 +0100231 parserContext.m_completionIterator = boost::none;
Václav Kubernát8028f942019-09-25 16:03:23 +0200232 }
233};
234
Václav Kubernát6797df02019-03-18 20:21:50 +0100235struct create_class {
Václav Kubernátb61336d2018-05-28 17:35:03 +0200236 template <typename Iterator, typename Exception, typename Context>
Václav Kubernát41378452018-06-06 16:29:40 +0200237 x3::error_handler_result on_error(Iterator&, Iterator const&, Exception const&, Context const& context)
Václav Kubernátb61336d2018-05-28 17:35:03 +0200238 {
239 auto& parserContext = x3::get<parser_context_tag>(context);
Václav Kubernát41378452018-06-06 16:29:40 +0200240 if (parserContext.m_errorMsg.empty())
241 parserContext.m_errorMsg = "Couldn't parse create/delete command.";
242 return x3::error_handler_result::rethrow;
Václav Kubernátb61336d2018-05-28 17:35:03 +0200243 }
244};
245
Václav Kubernát6797df02019-03-18 20:21:50 +0100246struct delete_class {
247 template <typename Iterator, typename Exception, typename Context>
248 x3::error_handler_result on_error(Iterator&, Iterator const&, Exception const&, Context const& context)
249 {
250 auto& parserContext = x3::get<parser_context_tag>(context);
251 if (parserContext.m_errorMsg.empty())
252 parserContext.m_errorMsg = "Couldn't parse create/delete command.";
253 return x3::error_handler_result::rethrow;
254 }
Václav Kubernátb61336d2018-05-28 17:35:03 +0200255};
256
Václav Kubernátabf52802020-05-19 01:31:17 +0200257struct writable_leaf_path_class {
Václav Kubernát0b0272f2018-06-13 14:13:08 +0200258 template <typename T, typename Iterator, typename Context>
Václav Kubernát7707cae2020-01-16 12:04:53 +0100259 void on_success(Iterator const&, Iterator const&, T&, Context const& context)
Václav Kubernát0b0272f2018-06-13 14:13:08 +0200260 {
261 auto& parserContext = x3::get<parser_context_tag>(context);
Václav Kubernát0d42c512020-05-20 21:18:39 +0200262 if (parserContext.currentSchemaPath().m_nodes.empty()) {
263 parserContext.m_errorMsg = "This is not a path to leaf.";
264 _pass(context) = false;
265 return;
266 }
267
Václav Kubernát0b0272f2018-06-13 14:13:08 +0200268 try {
Václav Kubernát7707cae2020-01-16 12:04:53 +0100269 auto lastNode = parserContext.currentSchemaPath().m_nodes.back();
270 auto leaf = boost::get<leaf_>(lastNode.m_suffix);
271 auto location = pathWithoutLastNode(parserContext.currentSchemaPath());
272 ModuleNodePair node{lastNode.m_prefix.flat_map([](const auto& it) { return boost::optional<std::string>{it.m_name}; }), leaf.m_name};
273
274 parserContext.m_tmpListKeyLeafPath.m_location = location;
275 parserContext.m_tmpListKeyLeafPath.m_node = node;
276
Václav Kubernát0b0272f2018-06-13 14:13:08 +0200277 } catch (boost::bad_get&) {
278 parserContext.m_errorMsg = "This is not a path to leaf.";
279 _pass(context) = false;
280 }
281 }
282};
283
Václav Kubernáteeb38842019-03-20 19:46:05 +0100284// This handler only checks if the module exists
285// It doesn't set any ParserContext flags (except the error message)
286struct data_module_prefix_class {
287 template <typename T, typename Iterator, typename Context>
288 void on_success(Iterator const&, Iterator const&, T& ast, Context const& context)
289 {
290 auto& parserContext = x3::get<parser_context_tag>(context);
291 const auto& schema = parserContext.m_schema;
292
Václav Kubernát72749c62020-01-03 16:47:34 +0100293 if (!schema.isModule(parserContext.currentSchemaPath(), ast.m_name)) {
Václav Kubernáteeb38842019-03-20 19:46:05 +0100294 parserContext.m_errorMsg = "Invalid module name.";
295 _pass(context) = false;
296 }
297 }
298};
299
Václav Kubernát07204242018-06-04 18:12:09 +0200300struct set_class {
Václav Kubernát07204242018-06-04 18:12:09 +0200301 template <typename Iterator, typename Exception, typename Context>
302 x3::error_handler_result on_error(Iterator&, Iterator const&, Exception const& x, Context const& context)
303 {
304 auto& parserContext = x3::get<parser_context_tag>(context);
Václav Kubernát41378452018-06-06 16:29:40 +0200305 if (parserContext.m_errorMsg.empty())
306 parserContext.m_errorMsg = "Expected " + x.which() + " here:";
307 return x3::error_handler_result::rethrow;
Václav Kubernát07204242018-06-04 18:12:09 +0200308 }
309};
310
Václav Kubernát812ee282018-08-30 17:10:03 +0200311struct commit_class;
312
Václav Kubernát9cfcd872020-02-18 12:34:02 +0100313struct describe_class;
314
Václav Kubernát054cc992019-02-21 14:23:52 +0100315struct help_class;
316
Václav Kubernátb6ff0b62018-08-30 16:14:53 +0200317struct get_class;
318
Václav Kubernát7160a132020-04-03 02:11:01 +0200319struct copy_class;
320
Václav Kubernátb61336d2018-05-28 17:35:03 +0200321struct command_class {
322 template <typename Iterator, typename Exception, typename Context>
323 x3::error_handler_result on_error(Iterator&, Iterator const&, Exception const& x, Context const& context)
324 {
325 auto& parserContext = x3::get<parser_context_tag>(context);
326 auto& error_handler = x3::get<x3::error_handler_tag>(context).get();
Václav Kubernát41378452018-06-06 16:29:40 +0200327 if (parserContext.m_errorMsg.empty()) {
328 parserContext.m_errorMsg = "Unknown command.";
329 }
330 error_handler(x.where(), parserContext.m_errorMsg);
Václav Kubernátb61336d2018-05-28 17:35:03 +0200331 return x3::error_handler_result::fail;
332 }
333};
Václav Kubernát5c75b252018-10-10 18:33:47 +0200334
Václav Kubernát4108e0d2018-10-29 13:32:22 +0100335struct initializePath_class {
Václav Kubernát5c75b252018-10-10 18:33:47 +0200336 template <typename T, typename Iterator, typename Context>
337 void on_success(Iterator const&, Iterator const&, T&, Context const& context)
338 {
339 auto& parserContext = x3::get<parser_context_tag>(context);
Václav Kubernát72749c62020-01-03 16:47:34 +0100340 parserContext.resetPath();
Václav Kubernát5c75b252018-10-10 18:33:47 +0200341 parserContext.m_tmpListKeys.clear();
342 parserContext.m_tmpListName.clear();
Václav Kubernát4108e0d2018-10-29 13:32:22 +0100343 parserContext.m_suggestions.clear();
Václav Kubernát5c75b252018-10-10 18:33:47 +0200344 }
345};
Václav Kubernátd6fd2492018-11-19 15:11:16 +0100346
347struct trailingSlash_class;
Václav Kubernát4108e0d2018-10-29 13:32:22 +0100348
Václav Kubernátcb3af402020-02-12 16:49:17 +0100349std::set<Completion> generateMissingKeyCompletionSet(std::set<std::string> keysNeeded, std::map<std::string, leaf_data_> currentSet);
Václav Kubernát329c6c32019-02-06 16:41:53 +0100350
351struct createKeySuggestions_class {
352 template <typename T, typename Iterator, typename Context>
353 void on_success(Iterator const& begin, Iterator const&, T&, Context const& context)
354 {
355 auto& parserContext = x3::get<parser_context_tag>(context);
356 const auto& schema = parserContext.m_schema;
357
358 parserContext.m_completionIterator = begin;
359
Václav Kubernát72749c62020-01-03 16:47:34 +0100360 const auto& keysNeeded = schema.listKeys(parserContext.currentSchemaPath(), {parserContext.m_curModule, parserContext.m_tmpListName});
Václav Kubernát329c6c32019-02-06 16:41:53 +0100361 parserContext.m_suggestions = generateMissingKeyCompletionSet(keysNeeded, parserContext.m_tmpListKeys);
362 }
363};
364
Václav Kubernát43908fb2020-01-02 19:05:51 +0100365std::string leafDataToCompletion(const leaf_data_& value);
366
367struct createValueSuggestions_class {
368 template <typename T, typename Iterator, typename Context>
369 void on_success(Iterator const& begin, Iterator const&, T&, Context const& context)
370 {
371 auto& parserContext = x3::get<parser_context_tag>(context);
372 if (!parserContext.m_completing) {
373 return;
374 }
375 const auto& dataQuery = parserContext.m_dataquery;
376
377 parserContext.m_completionIterator = begin;
378 auto listInstances = dataQuery->listKeys(parserContext.currentDataPath(), {parserContext.m_curModule, parserContext.m_tmpListName});
379
380 decltype(listInstances) filteredInstances;
381 //This filters out instances, which don't correspond to the partial instance we have.
382 const auto partialFitsComplete = [&parserContext] (const auto& complete) {
383 const auto& partial = parserContext.m_tmpListKeys;
384 return std::all_of(partial.begin(), partial.end(), [&complete] (const auto& oneKV) {
385 const auto& [k, v] = oneKV;
386 return complete.at(k) == v;
387 });
388 };
389 std::copy_if(listInstances.begin(), listInstances.end(), std::inserter(filteredInstances, filteredInstances.end()), partialFitsComplete);
390
Václav Kubernátcb3af402020-02-12 16:49:17 +0100391 std::set<Completion> validValues;
Václav Kubernát43908fb2020-01-02 19:05:51 +0100392
Václav Kubernátcb3af402020-02-12 16:49:17 +0100393 std::transform(filteredInstances.begin(), filteredInstances.end(), std::inserter(validValues, validValues.end()), [&parserContext](const auto& instance) {
394 return Completion{leafDataToCompletion(instance.at(parserContext.m_tmpListKeyLeafPath.m_node.second))};
Václav Kubernát43908fb2020-01-02 19:05:51 +0100395 });
396
397 parserContext.m_suggestions = validValues;
398 }
399};
400
Václav Kubernát329c6c32019-02-06 16:41:53 +0100401struct suggestKeysEnd_class {
402 template <typename T, typename Iterator, typename Context>
403 void on_success(Iterator const& begin, Iterator const&, T&, Context const& context)
404 {
405 auto& parserContext = x3::get<parser_context_tag>(context);
406 const auto& schema = parserContext.m_schema;
407
408 parserContext.m_completionIterator = begin;
Václav Kubernát72749c62020-01-03 16:47:34 +0100409 const auto& keysNeeded = schema.listKeys(parserContext.currentSchemaPath(), {parserContext.m_curModule, parserContext.m_tmpListName});
Václav Kubernát329c6c32019-02-06 16:41:53 +0100410 if (generateMissingKeyCompletionSet(keysNeeded, parserContext.m_tmpListKeys).empty()) {
Václav Kubernátcb3af402020-02-12 16:49:17 +0100411 parserContext.m_suggestions = {Completion{"]/"}};
Václav Kubernát329c6c32019-02-06 16:41:53 +0100412 } else {
Václav Kubernátcb3af402020-02-12 16:49:17 +0100413 parserContext.m_suggestions = {Completion{"]["}};
Václav Kubernát329c6c32019-02-06 16:41:53 +0100414 }
415 }
416};
Václav Kubernát57272422019-02-08 12:48:24 +0100417
418struct commandNamesVisitor {
419 template <typename T>
Václav Kubernátcb3af402020-02-12 16:49:17 +0100420 std::string operator()(boost::type<T>)
Václav Kubernát57272422019-02-08 12:48:24 +0100421 {
422 return T::name;
423 }
424};
425
426struct createCommandSuggestions_class {
427 template <typename T, typename Iterator, typename Context>
428 void on_success(Iterator const& begin, Iterator const&, T&, Context const& context)
429 {
430 auto& parserContext = x3::get<parser_context_tag>(context);
431 parserContext.m_completionIterator = begin;
432
433 parserContext.m_suggestions.clear();
434 boost::mpl::for_each<CommandTypes, boost::type<boost::mpl::_>>([&parserContext](auto cmd) {
Václav Kubernát0165e6c2020-02-17 18:18:14 +0100435 parserContext.m_suggestions.insert({commandNamesVisitor()(cmd), " "});
Václav Kubernát57272422019-02-08 12:48:24 +0100436 });
437 }
438};
Václav Kubernátac035d62019-02-18 10:59:08 +0100439
440struct completing_class {
441 template <typename T, typename Iterator, typename Context>
442 void on_success(Iterator const&, Iterator const&, T&, Context const& context)
443 {
444 auto& parserContext = x3::get<parser_context_tag>(context);
445
446 if (!parserContext.m_completing)
447 _pass(context) = false;
448 }
449};