blob: bb622ef18258fb77e61eb6a4e666ec2cbd0e1934 [file] [log] [blame]
Václav Kubernátd0ea9b22020-04-24 00:44:15 +02001/*
2 * Copyright (C) 2020 CESNET, https://photonics.cesnet.cz/
3 *
4 * Written by Václav Kubernát <kubernat@cesnet.cz>
5 *
6*/
7
8#pragma once
9
10#include <boost/spirit/home/x3.hpp>
11#include "ast_handlers.hpp"
12#include "common_parsers.hpp"
13#include "leaf_data.hpp"
14
15namespace x3 = boost::spirit::x3;
16
Václav Kubernátabf52802020-05-19 01:31:17 +020017x3::rule<writable_leaf_path_class, dataPath_> const writableLeafPath = "writableLeafPath";
Václav Kubernátd0ea9b22020-04-24 00:44:15 +020018x3::rule<presenceContainerPath_class, dataPath_> const presenceContainerPath = "presenceContainerPath";
19x3::rule<listInstancePath_class, dataPath_> const listInstancePath = "listInstancePath";
Václav Kubernát5b8a8f32020-05-20 00:57:22 +020020x3::rule<leafListElementPath_class, dataPath_> const leafListElementPath = "leafListElementPath";
Václav Kubernátd0ea9b22020-04-24 00:44:15 +020021x3::rule<initializePath_class, x3::unused_type> const initializePath = "initializePath";
Václav Kubernátd0ea9b22020-04-24 00:44:15 +020022x3::rule<trailingSlash_class, TrailingSlash> const trailingSlash = "trailingSlash";
Václav Kubernátd0ea9b22020-04-24 00:44:15 +020023x3::rule<absoluteStart_class, Scope> const absoluteStart = "absoluteStart";
24x3::rule<keyValue_class, keyValue_> const keyValue = "keyValue";
25x3::rule<key_identifier_class, std::string> const key_identifier = "key_identifier";
Václav Kubernátd0ea9b22020-04-24 00:44:15 +020026x3::rule<listSuffix_class, std::vector<keyValue_>> const listSuffix = "listSuffix";
Václav Kubernátd0ea9b22020-04-24 00:44:15 +020027x3::rule<createKeySuggestions_class, x3::unused_type> const createKeySuggestions = "createKeySuggestions";
28x3::rule<createValueSuggestions_class, x3::unused_type> const createValueSuggestions = "createValueSuggestions";
29x3::rule<suggestKeysEnd_class, x3::unused_type> const suggestKeysEnd = "suggestKeysEnd";
Václav Kubernát5b8a8f32020-05-20 00:57:22 +020030x3::rule<class leafListValue_class, leaf_data_> const leafListValue = "leafListValue";
Václav Kubernátd0ea9b22020-04-24 00:44:15 +020031
Václav Kubernát4a58ce62020-05-14 17:58:10 +020032enum class NodeParserMode {
33 CompleteDataNode,
34 IncompleteDataNode,
35 CompletionsOnly,
36 SchemaNode
37};
38
39template <auto>
40struct ModeToAttribute;
41template <>
42struct ModeToAttribute<NodeParserMode::CompleteDataNode> {
43 using type = dataNode_;
44};
45template <>
46struct ModeToAttribute<NodeParserMode::IncompleteDataNode> {
47 using type = dataNode_;
48};
49template <>
50struct ModeToAttribute<NodeParserMode::SchemaNode> {
51 using type = schemaNode_;
52};
53// The CompletionsOnly attribute is dataNode_ only because of convenience:
54// having the same return type means we can get by without a ton of `if constexpr` stanzas.
55// So the code will still "parse data into the target attr" for simplicity.
56template <>
57struct ModeToAttribute<NodeParserMode::CompletionsOnly> {
58 using type = dataNode_;
59};
60
Václav Kubernát743d9eb2020-05-18 13:42:36 +020061enum class CompletionMode {
62 Schema,
63 Data
64};
Václav Kubernát5b8a8f32020-05-20 00:57:22 +020065
Václav Kubernát743d9eb2020-05-18 13:42:36 +020066template <NodeParserMode PARSER_MODE, CompletionMode COMPLETION_MODE>
67struct NodeParser : x3::parser<NodeParser<PARSER_MODE, COMPLETION_MODE>> {
Václav Kubernát4a58ce62020-05-14 17:58:10 +020068 using attribute_type = typename ModeToAttribute<PARSER_MODE>::type;
Václav Kubernátabf52802020-05-19 01:31:17 +020069
70 std::function<bool(const Schema&, const std::string& path)> m_filterFunction;
71
72 NodeParser(const std::function<bool(const Schema&, const std::string& path)>& filterFunction)
73 : m_filterFunction(filterFunction)
74 {
75 }
76
Václav Kubernát4a58ce62020-05-14 17:58:10 +020077 // GCC complains that `end` isn't used when doing completions only
78 // FIXME: GCC 10.1 doesn't emit a warning here. Remove [[maybe_unused]] when GCC 10 is available
Václav Kubernát60a0ed52020-04-28 15:21:33 +020079 template <typename It, typename Ctx, typename RCtx, typename Attr>
Václav Kubernát4a58ce62020-05-14 17:58:10 +020080 bool parse(It& begin, [[maybe_unused]] It end, Ctx const& ctx, RCtx& rctx, Attr& attr) const
Václav Kubernát60a0ed52020-04-28 15:21:33 +020081 {
Václav Kubernátdd5945a2020-05-05 01:24:23 +020082 std::string tableName;
Václav Kubernát4a58ce62020-05-14 17:58:10 +020083 if constexpr (std::is_same<attribute_type, schemaNode_>()) {
Václav Kubernátdd5945a2020-05-05 01:24:23 +020084 tableName = "schemaNode";
85 } else {
86 tableName = "dataNode";
87 }
Václav Kubernát4a58ce62020-05-14 17:58:10 +020088 x3::symbols<attribute_type> table(tableName);
Václav Kubernát60a0ed52020-04-28 15:21:33 +020089
90 ParserContext& parserContext = x3::get<parser_context_tag>(ctx);
91 parserContext.m_suggestions.clear();
92 for (const auto& child : parserContext.m_schema.availableNodes(parserContext.currentSchemaPath(), Recursion::NonRecursive)) {
Václav Kubernát4a58ce62020-05-14 17:58:10 +020093 attribute_type out;
Václav Kubernát60a0ed52020-04-28 15:21:33 +020094 std::string parseString;
95 if (child.first) {
96 out.m_prefix = module_{*child.first};
97 parseString = *child.first + ":";
98 }
99 parseString += child.second;
Václav Kubernátabf52802020-05-19 01:31:17 +0200100
101 if (!m_filterFunction(parserContext.m_schema, joinPaths(pathToSchemaString(parserContext.currentSchemaPath(), Prefixes::Always), parseString))) {
102 continue;
103 }
104
Václav Kubernát60a0ed52020-04-28 15:21:33 +0200105 switch (parserContext.m_schema.nodeType(parserContext.currentSchemaPath(), child)) {
106 case yang::NodeTypes::Container:
107 case yang::NodeTypes::PresenceContainer:
108 out.m_suffix = container_{child.second};
109 parserContext.m_suggestions.emplace(Completion{parseString + "/"});
110 break;
111 case yang::NodeTypes::Leaf:
112 out.m_suffix = leaf_{child.second};
113 parserContext.m_suggestions.emplace(Completion{parseString + " "});
114 break;
115 case yang::NodeTypes::List:
Václav Kubernát4a58ce62020-05-14 17:58:10 +0200116 if constexpr (std::is_same<attribute_type, schemaNode_>()) {
Václav Kubernátdd5945a2020-05-05 01:24:23 +0200117 out.m_suffix = list_{child.second};
118 } else {
119 out.m_suffix = listElement_{child.second, {}};
120 }
Václav Kubernát743d9eb2020-05-18 13:42:36 +0200121
122 if constexpr (COMPLETION_MODE == CompletionMode::Schema) {
123 parserContext.m_suggestions.emplace(Completion{parseString + "/"});
124 } else {
125 parserContext.m_suggestions.emplace(Completion{parseString, "[", Completion::WhenToAdd::IfFullMatch});
126 }
Václav Kubernát60a0ed52020-04-28 15:21:33 +0200127 break;
Václav Kubernát5b8a8f32020-05-20 00:57:22 +0200128 case yang::NodeTypes::LeafList:
129 if constexpr (std::is_same<attribute_type, schemaNode_>()) {
130 out.m_suffix = leafList_{child.second};
131 } else {
132 out.m_suffix = leafListElement_{child.second, {}};
133 }
Václav Kubernát743d9eb2020-05-18 13:42:36 +0200134
135 if constexpr (COMPLETION_MODE == CompletionMode::Schema) {
136 parserContext.m_suggestions.emplace(Completion{parseString + "/"});
137 } else {
138 parserContext.m_suggestions.emplace(Completion{parseString, "[", Completion::WhenToAdd::IfFullMatch});
139 }
Václav Kubernát5b8a8f32020-05-20 00:57:22 +0200140 break;
Václav Kubernát60a0ed52020-04-28 15:21:33 +0200141 case yang::NodeTypes::Action:
142 case yang::NodeTypes::AnyXml:
Václav Kubernát60a0ed52020-04-28 15:21:33 +0200143 case yang::NodeTypes::Notification:
144 case yang::NodeTypes::Rpc:
145 continue;
146 }
147 table.add(parseString, out);
Václav Kubernát4a58ce62020-05-14 17:58:10 +0200148 table.add("..", attribute_type{nodeup_{}});
Václav Kubernát60a0ed52020-04-28 15:21:33 +0200149 if (!child.first) {
150 auto topLevelModule = parserContext.currentSchemaPath().m_nodes.begin()->m_prefix;
151 out.m_prefix = topLevelModule;
152 table.add(topLevelModule->m_name + ":" + parseString, out);
153 }
154 }
Václav Kubernátdd5945a2020-05-05 01:24:23 +0200155 parserContext.m_completionIterator = begin;
Václav Kubernátdd5945a2020-05-05 01:24:23 +0200156
Václav Kubernát4a58ce62020-05-14 17:58:10 +0200157 if constexpr (PARSER_MODE == NodeParserMode::CompletionsOnly) {
158 return true;
159 } else {
160 It saveIter;
161 // GCC complains that I assign saveIter because I use it only if NodeType is dataNode_
162 // FIXME: GCC 10.1 doesn't emit a warning here. Make this unconditional when GCC 10 is available.
163 if constexpr (std::is_same<attribute_type, dataNode_>()) {
164 saveIter = begin;
Václav Kubernátdd5945a2020-05-05 01:24:23 +0200165 }
Václav Kubernátdd5945a2020-05-05 01:24:23 +0200166
Václav Kubernát4a58ce62020-05-14 17:58:10 +0200167 auto res = table.parse(begin, end, ctx, rctx, attr);
Václav Kubernátdd5945a2020-05-05 01:24:23 +0200168
Václav Kubernát4a58ce62020-05-14 17:58:10 +0200169 if (attr.m_prefix) {
170 parserContext.m_curModule = attr.m_prefix->m_name;
171 }
172
Václav Kubernátb5ca1542020-05-27 01:03:54 +0200173 if (std::holds_alternative<leaf_>(attr.m_suffix)) {
Václav Kubernát4a58ce62020-05-14 17:58:10 +0200174 parserContext.m_tmpListKeyLeafPath.m_location = parserContext.currentSchemaPath();
175 ModuleNodePair node{attr.m_prefix.flat_map([](const auto& it) {
176 return boost::optional<std::string>{it.m_name};
177 }),
Václav Kubernátb5ca1542020-05-27 01:03:54 +0200178 std::get<leaf_>(attr.m_suffix).m_name};
Václav Kubernát4a58ce62020-05-14 17:58:10 +0200179 parserContext.m_tmpListKeyLeafPath.m_node = node;
180 }
181
182 if constexpr (std::is_same<attribute_type, dataNode_>()) {
Václav Kubernátb5ca1542020-05-27 01:03:54 +0200183 if (std::holds_alternative<listElement_>(attr.m_suffix)) {
184 parserContext.m_tmpListName = std::get<listElement_>(attr.m_suffix).m_name;
185 res = listSuffix.parse(begin, end, ctx, rctx, std::get<listElement_>(attr.m_suffix).m_keys);
Václav Kubernát4a58ce62020-05-14 17:58:10 +0200186
187 // FIXME: think of a better way to do this, that is, get rid of manual iterator reverting
188 if (!res) {
189 // If listSuffix didn't succeed, we check, if we allow incomplete nodes. If we do, then we replace listElement_ with list_.
190 // If we don't, we fail the whole symbol table.
191 if constexpr (PARSER_MODE == NodeParserMode::IncompleteDataNode) {
192 res = true;
Václav Kubernátb5ca1542020-05-27 01:03:54 +0200193 attr.m_suffix = list_{std::get<listElement_>(attr.m_suffix).m_name};
Václav Kubernát4a58ce62020-05-14 17:58:10 +0200194 } else {
195 begin = saveIter;
196 }
197 }
198 }
Václav Kubernát5b8a8f32020-05-20 00:57:22 +0200199
Václav Kubernátb5ca1542020-05-27 01:03:54 +0200200 if (std::holds_alternative<leafListElement_>(attr.m_suffix)) {
Václav Kubernát5b8a8f32020-05-20 00:57:22 +0200201 parserContext.m_tmpListKeyLeafPath.m_location = parserContext.currentSchemaPath();
202 ModuleNodePair node{attr.m_prefix.flat_map([](const auto& it) {
203 return boost::optional<std::string>{it.m_name};
204 }),
Václav Kubernátb5ca1542020-05-27 01:03:54 +0200205 std::get<leafListElement_>(attr.m_suffix).m_name};
Václav Kubernát5b8a8f32020-05-20 00:57:22 +0200206 parserContext.m_tmpListKeyLeafPath.m_node = node;
Václav Kubernátb5ca1542020-05-27 01:03:54 +0200207 res = leafListValue.parse(begin, end, ctx, rctx, std::get<leafListElement_>(attr.m_suffix).m_value);
Václav Kubernát5b8a8f32020-05-20 00:57:22 +0200208
209 if (!res) {
210 if constexpr (PARSER_MODE == NodeParserMode::IncompleteDataNode) {
211 res = true;
Václav Kubernátb5ca1542020-05-27 01:03:54 +0200212 attr.m_suffix = leafList_{std::get<leafListElement_>(attr.m_suffix).m_name};
Václav Kubernát5b8a8f32020-05-20 00:57:22 +0200213 } else {
214 begin = saveIter;
215 }
216 }
217 }
Václav Kubernát4a58ce62020-05-14 17:58:10 +0200218 }
219
220 if (res) {
221 parserContext.pushPathFragment(attr);
222 parserContext.m_topLevelModulePresent = true;
223 }
224
225 if (attr.m_prefix) {
226 parserContext.m_curModule = boost::none;
227 }
228 return res;
Václav Kubernát60a0ed52020-04-28 15:21:33 +0200229 }
Václav Kubernát60a0ed52020-04-28 15:21:33 +0200230 }
Václav Kubernátdd5945a2020-05-05 01:24:23 +0200231};
232
Václav Kubernát743d9eb2020-05-18 13:42:36 +0200233template <CompletionMode COMPLETION_MODE> using schemaNode = NodeParser<NodeParserMode::SchemaNode, COMPLETION_MODE>;
234template <CompletionMode COMPLETION_MODE> using dataNode = NodeParser<NodeParserMode::CompleteDataNode, COMPLETION_MODE>;
235template <CompletionMode COMPLETION_MODE> using incompleteDataNode = NodeParser<NodeParserMode::IncompleteDataNode, COMPLETION_MODE>;
236template <CompletionMode COMPLETION_MODE> using pathCompletions = NodeParser<NodeParserMode::CompletionsOnly, COMPLETION_MODE>;
Václav Kubernát60a0ed52020-04-28 15:21:33 +0200237
Václav Kubernát4618fa42020-05-07 01:33:19 +0200238using AnyPath = boost::variant<schemaPath_, dataPath_>;
239
Václav Kubernát4a58ce62020-05-14 17:58:10 +0200240enum class PathParserMode {
241 AnyPath,
242 DataPath,
243 DataPathListEnd
244};
245
246template <>
247struct ModeToAttribute<PathParserMode::AnyPath> {
248 using type = AnyPath;
249};
250
251template <>
252struct ModeToAttribute<PathParserMode::DataPath> {
253 using type = dataPath_;
254};
255
256template <>
257struct ModeToAttribute<PathParserMode::DataPathListEnd> {
258 using type = dataPath_;
259};
260
Václav Kubernát743d9eb2020-05-18 13:42:36 +0200261template <PathParserMode PARSER_MODE, CompletionMode COMPLETION_MODE>
262struct PathParser : x3::parser<PathParser<PARSER_MODE, COMPLETION_MODE>> {
Václav Kubernát4a58ce62020-05-14 17:58:10 +0200263 using attribute_type = ModeToAttribute<PARSER_MODE>;
Václav Kubernátabf52802020-05-19 01:31:17 +0200264 std::function<bool(const Schema&, const std::string& path)> m_filterFunction;
265
266 PathParser(const std::function<bool(const Schema&, const std::string& path)>& filterFunction = [] (const auto&, const auto&) {return true;})
267 : m_filterFunction(filterFunction)
268 {
269 }
270
Václav Kubernát4618fa42020-05-07 01:33:19 +0200271 template <typename It, typename Ctx, typename RCtx, typename Attr>
272 bool parse(It& begin, It end, Ctx const& ctx, RCtx& rctx, Attr& attr) const
273 {
Václav Kubernát74d35a42020-05-15 15:29:16 +0200274 initializePath.parse(begin, end, ctx, rctx, x3::unused);
Václav Kubernát4618fa42020-05-07 01:33:19 +0200275 dataPath_ attrData;
276
Václav Kubernát4a58ce62020-05-14 17:58:10 +0200277 auto pathEnd = x3::rule<class PathEnd>{"pathEnd"} = &space_separator | x3::eoi;
Václav Kubernát4618fa42020-05-07 01:33:19 +0200278 // absoluteStart has to be separate from the dataPath parser,
279 // otherwise, if the "dataNode % '/'" parser fails, the begin iterator
280 // gets reverted to before the starting slash.
Václav Kubernát4a58ce62020-05-14 17:58:10 +0200281 auto res = (-absoluteStart).parse(begin, end, ctx, rctx, attrData.m_scope);
282 auto dataPath = x3::attr(attrData.m_scope)
Václav Kubernát743d9eb2020-05-18 13:42:36 +0200283 >> (dataNode<COMPLETION_MODE>{m_filterFunction} % '/' | pathEnd >> x3::attr(std::vector<dataNode_>{}))
Václav Kubernát4a58ce62020-05-14 17:58:10 +0200284 >> -trailingSlash;
Václav Kubernát4618fa42020-05-07 01:33:19 +0200285 res = dataPath.parse(begin, end, ctx, rctx, attrData);
Václav Kubernát4618fa42020-05-07 01:33:19 +0200286
Václav Kubernát4a58ce62020-05-14 17:58:10 +0200287 // If we allow data paths with a list at the end, we just try to parse that separately.
288 if constexpr (PARSER_MODE == PathParserMode::DataPathListEnd || PARSER_MODE == PathParserMode::AnyPath) {
Václav Kubernát4618fa42020-05-07 01:33:19 +0200289 if (!res || !pathEnd.parse(begin, end, ctx, rctx, x3::unused)) {
Václav Kubernát4a58ce62020-05-14 17:58:10 +0200290 dataNode_ attrNodeList;
Václav Kubernát743d9eb2020-05-18 13:42:36 +0200291 res = incompleteDataNode<COMPLETION_MODE>{m_filterFunction}.parse(begin, end, ctx, rctx, attrNodeList);
Václav Kubernát4a58ce62020-05-14 17:58:10 +0200292 if (res) {
293 attrData.m_nodes.push_back(attrNodeList);
294 // If the trailing slash matches, no more nodes are parsed.
295 // That means no more completion. So, I generate them
296 // manually.
Václav Kubernát743d9eb2020-05-18 13:42:36 +0200297 res = (-(trailingSlash >> x3::omit[pathCompletions<COMPLETION_MODE>{m_filterFunction}])).parse(begin, end, ctx, rctx, attrData.m_trailingSlash);
Václav Kubernát4a58ce62020-05-14 17:58:10 +0200298 }
299 }
300 }
301
302 attr = attrData;
303 if constexpr (PARSER_MODE == PathParserMode::AnyPath) {
304 // If our data path already has some listElement_ fragments, we can't parse rest of the path as a schema path
305 auto hasLists = std::any_of(attrData.m_nodes.begin(), attrData.m_nodes.end(),
Václav Kubernátb5ca1542020-05-27 01:03:54 +0200306 [] (const auto& node) { return std::holds_alternative<listElement_>(node.m_suffix); });
Václav Kubernát4a58ce62020-05-14 17:58:10 +0200307 // If parsing failed, or if there's more input we try parsing schema nodes.
308 if (!hasLists) {
309 if (!res || !pathEnd.parse(begin, end, ctx, rctx, x3::unused)) {
310 // If dataPath parsed some nodes, they will be saved in `attrData`. We have to keep these.
311 schemaPath_ attrSchema = dataPathToSchemaPath(attrData);
Václav Kubernát743d9eb2020-05-18 13:42:36 +0200312 auto schemaPath = schemaNode<COMPLETION_MODE>{m_filterFunction} % '/';
Václav Kubernát4a58ce62020-05-14 17:58:10 +0200313 // The schemaPath parser continues where the dataPath parser ended.
314 res = schemaPath.parse(begin, end, ctx, rctx, attrSchema.m_nodes);
315 auto trailing = -trailingSlash >> pathEnd;
316 res = trailing.parse(begin, end, ctx, rctx, attrSchema.m_trailingSlash);
317 attr = attrSchema;
318 }
Václav Kubernát4618fa42020-05-07 01:33:19 +0200319 }
320 }
321 return res;
322 }
Václav Kubernát74d35a42020-05-15 15:29:16 +0200323};
Václav Kubernát4618fa42020-05-07 01:33:19 +0200324
325// Need to use these wrappers so that my PathParser class gets the proper
326// attribute. Otherwise, Spirit injects the attribute of the outer parser that
327// uses my PathParser.
328// Example grammar: anyPath | module.
329// The PathParser class would get a boost::variant as the attribute, but I
330// don't want to deal with that, so I use these wrappers to ensure the
Václav Kubernát74d35a42020-05-15 15:29:16 +0200331// attribute I want (and let Spirit deal with boost::variant).
Václav Kubernát743d9eb2020-05-18 13:42:36 +0200332auto const anyPath = x3::rule<class anyPath_class, AnyPath>{"anyPath"} = PathParser<PathParserMode::AnyPath, CompletionMode::Schema>{};
333auto const dataPath = x3::rule<class dataPath_class, dataPath_>{"dataPath"} = PathParser<PathParserMode::DataPath, CompletionMode::Data>{};
334auto const dataPathListEnd = x3::rule<class dataPath_class, dataPath_>{"dataPath"} = PathParser<PathParserMode::DataPathListEnd, CompletionMode::Data>{};
Václav Kubernát4618fa42020-05-07 01:33:19 +0200335
Václav Kubernátd0ea9b22020-04-24 00:44:15 +0200336#if __clang__
337#pragma GCC diagnostic push
338#pragma GCC diagnostic ignored "-Woverloaded-shift-op-parentheses"
339#endif
340
Václav Kubernát5b8a8f32020-05-20 00:57:22 +0200341struct SuggestLeafListEnd : x3::parser<SuggestLeafListEnd> {
342 using attribute_type = x3::unused_type;
343 template <typename It, typename Ctx, typename RCtx, typename Attr>
344 bool parse(It& begin, It, Ctx const& ctx, RCtx&, Attr&) const
345 {
346 auto& parserContext = x3::get<parser_context_tag>(ctx);
347 parserContext.m_completionIterator = begin;
348 parserContext.m_suggestions = {Completion{"]"}};
349
350 return true;
351 }
352} const suggestLeafListEnd;
353
354auto const leafListValue_def =
355 '[' >> leaf_data >> suggestLeafListEnd >> ']';
356
Václav Kubernátd0ea9b22020-04-24 00:44:15 +0200357auto const rest =
358 x3::omit[x3::no_skip[+(x3::char_ - '/' - space_separator)]];
359
360auto const key_identifier_def =
361 x3::lexeme[
362 ((x3::alpha | char_("_")) >> *(x3::alnum | char_("_") | char_("-") | char_(".")))
363 ];
364
365auto const createKeySuggestions_def =
366 x3::eps;
367
368auto const createValueSuggestions_def =
369 x3::eps;
370
371auto const suggestKeysEnd_def =
372 x3::eps;
373
374auto const keyValue_def =
375 key_identifier > '=' > createValueSuggestions > leaf_data;
376
377auto const keyValueWrapper =
378 x3::lexeme['[' > createKeySuggestions > keyValue > suggestKeysEnd > ']'];
379
Václav Kubernátd0ea9b22020-04-24 00:44:15 +0200380// even though we don't allow no keys to be supplied, the star allows me to check which keys are missing
381auto const listSuffix_def =
382 *keyValueWrapper;
383
Václav Kubernátd0ea9b22020-04-24 00:44:15 +0200384auto const list_def =
385 node_identifier >> !char_('[');
386
Václav Kubernátd0ea9b22020-04-24 00:44:15 +0200387auto const absoluteStart_def =
388 x3::omit['/'] >> x3::attr(Scope::Absolute);
389
390auto const trailingSlash_def =
391 x3::omit['/'] >> x3::attr(TrailingSlash::Present);
392
Václav Kubernátabf52802020-05-19 01:31:17 +0200393auto const filterConfigFalse = [] (const Schema& schema, const std::string& path) {
394 return schema.isConfig(path);
395};
396
397auto const writableLeafPath_def =
Václav Kubernát743d9eb2020-05-18 13:42:36 +0200398 PathParser<PathParserMode::DataPath, CompletionMode::Data>{filterConfigFalse};
Václav Kubernátd0ea9b22020-04-24 00:44:15 +0200399
400auto const presenceContainerPath_def =
401 dataPath;
402
403auto const listInstancePath_def =
404 dataPath;
405
Václav Kubernát5b8a8f32020-05-20 00:57:22 +0200406auto const leafListElementPath_def =
407 dataPath;
408
Václav Kubernátd0ea9b22020-04-24 00:44:15 +0200409// A "nothing" parser, which is used to indicate we tried to parse a path
410auto const initializePath_def =
411 x3::eps;
412
413
414
415#if __clang__
416#pragma GCC diagnostic pop
417#endif
418
419BOOST_SPIRIT_DEFINE(keyValue)
420BOOST_SPIRIT_DEFINE(key_identifier)
Václav Kubernátd0ea9b22020-04-24 00:44:15 +0200421BOOST_SPIRIT_DEFINE(listSuffix)
Václav Kubernátabf52802020-05-19 01:31:17 +0200422BOOST_SPIRIT_DEFINE(writableLeafPath)
Václav Kubernátd0ea9b22020-04-24 00:44:15 +0200423BOOST_SPIRIT_DEFINE(presenceContainerPath)
424BOOST_SPIRIT_DEFINE(listInstancePath)
Václav Kubernát5b8a8f32020-05-20 00:57:22 +0200425BOOST_SPIRIT_DEFINE(leafListElementPath)
Václav Kubernátd0ea9b22020-04-24 00:44:15 +0200426BOOST_SPIRIT_DEFINE(initializePath)
427BOOST_SPIRIT_DEFINE(createKeySuggestions)
Václav Kubernátd0ea9b22020-04-24 00:44:15 +0200428BOOST_SPIRIT_DEFINE(createValueSuggestions)
429BOOST_SPIRIT_DEFINE(suggestKeysEnd)
Václav Kubernát5b8a8f32020-05-20 00:57:22 +0200430BOOST_SPIRIT_DEFINE(leafListValue)
Václav Kubernátd0ea9b22020-04-24 00:44:15 +0200431BOOST_SPIRIT_DEFINE(absoluteStart)
432BOOST_SPIRIT_DEFINE(trailingSlash)