blob: e1514173084b0d70c04dbd7163afc0120942e41d [file] [log] [blame]
Václav Kubernát94938b72018-05-04 15:12:24 +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*/
Václav Kubernát2984f442020-02-20 17:43:35 +01008#include <experimental/iterator>
Václav Kubernát509ce652019-05-29 19:46:44 +02009#include <sstream>
Václav Kubernátcb3af402020-02-12 16:49:17 +010010#include "completion.hpp"
Václav Kubernát94938b72018-05-04 15:12:24 +020011#include "utils.hpp"
12
13std::string joinPaths(const std::string& prefix, const std::string& suffix)
14{
Václav Kubernáta44bdf22020-01-24 12:15:31 +010015 // These two if statements are essential for the algorithm:
16 // The first one solves joining nothing and a relative path - the algorithm
17 // down below adds a leading slash, turning it into an absolute path.
18 // The second one would always add a trailing slash to the path.
19 if (prefix.empty()) {
20 return suffix;
21 }
22
23 if (suffix.empty()) {
24 return prefix;
25 }
26
27 // Otherwise, strip slashes where the join is going to happen. This will
28 // also change "/" to "", but the return statement takes care of that and
29 // inserts the slash again.
30 auto prefixWithoutTrailingSlash = !prefix.empty() && prefix.back() == '/' ? prefix.substr(0, prefix.length() - 1) : prefix;
31 auto suffixWithoutLeadingSlash = !suffix.empty() && suffix.front() == '/' ? suffix.substr(1) : suffix;
32
33 // And join the result with a slash.
34 return prefixWithoutTrailingSlash + '/' + suffixWithoutLeadingSlash;
Václav Kubernát94938b72018-05-04 15:12:24 +020035}
Václav Kubernát60d6f292018-05-25 09:45:32 +020036
37std::string stripLastNodeFromPath(const std::string& path)
38{
39 std::string res = path;
40 auto pos = res.find_last_of('/');
Václav Kubernátefcac932020-01-10 15:26:32 +010041 if (pos == res.npos) { // path has no backslash - it's either empty, or is a relative path with one fragment
Václav Kubernát60d6f292018-05-25 09:45:32 +020042 res.clear();
Václav Kubernátefcac932020-01-10 15:26:32 +010043 } else if (pos == 0) { // path has one backslash at the start - it's either "/" or "/one-path-fragment"
44 return "/";
45 } else {
Václav Kubernát60d6f292018-05-25 09:45:32 +020046 res.erase(pos);
Václav Kubernátefcac932020-01-10 15:26:32 +010047 }
Václav Kubernát60d6f292018-05-25 09:45:32 +020048 return res;
49}
Václav Kubernátebca2552018-06-08 19:06:02 +020050
Václav Kubernát2eaceb82018-10-08 19:56:30 +020051schemaPath_ pathWithoutLastNode(const schemaPath_& path)
Václav Kubernátebca2552018-06-08 19:06:02 +020052{
Václav Kubernát2eaceb82018-10-08 19:56:30 +020053 return schemaPath_{path.m_scope, decltype(schemaPath_::m_nodes)(path.m_nodes.begin(), path.m_nodes.end() - 1)};
Václav Kubernátebca2552018-06-08 19:06:02 +020054}
Václav Kubernát0b0272f2018-06-13 14:13:08 +020055
Jan Kundrát6ebcc6c2020-05-07 01:58:51 +020056ModuleNodePair splitModuleNode(const std::string& input)
57{
58 auto colonLocation = input.find_first_of(':');
59 if (colonLocation != std::string::npos) {
60 return ModuleNodePair{input.substr(0, colonLocation), input.substr(colonLocation + 1)};
61 }
62 throw std::logic_error("Internal error: got module-unqualified node name");
63}
64
Václav Kubernát3a99f002020-03-31 02:27:41 +020065struct impl_leafDataTypeToString {
66 std::string operator()(const yang::String)
67 {
Václav Kubernát0b0272f2018-06-13 14:13:08 +020068 return "a string";
Václav Kubernát0b0272f2018-06-13 14:13:08 +020069 }
Václav Kubernát3a99f002020-03-31 02:27:41 +020070 std::string operator()(const yang::Decimal)
71 {
72 return "a decimal";
73 }
74 std::string operator()(const yang::Bool)
75 {
76 return "a boolean";
77 }
78 std::string operator()(const yang::Int8)
79 {
80 return "an 8-bit integer";
81 }
82 std::string operator()(const yang::Uint8)
83 {
84 return "an 8-bit unsigned integer";
85 }
86 std::string operator()(const yang::Int16)
87 {
88 return "a 16-bit integer";
89 }
90 std::string operator()(const yang::Uint16)
91 {
92 return "a 16-bit unsigned integer";
93 }
94 std::string operator()(const yang::Int32)
95 {
96 return "a 32-bit integer";
97 }
98 std::string operator()(const yang::Uint32)
99 {
100 return "a 32-bit unsigned integer";
101 }
102 std::string operator()(const yang::Int64)
103 {
104 return "a 64-bit integer";
105 }
106 std::string operator()(const yang::Uint64)
107 {
108 return "a 64-bit unsigned integer";
109 }
110 std::string operator()(const yang::Binary)
111 {
112 return "a base64-encoded binary value";
113 }
114 std::string operator()(const yang::Enum&)
115 {
116 return "an enum";
117 }
118 std::string operator()(const yang::IdentityRef&)
119 {
120 return "an identity";
121 }
122 std::string operator()(const yang::LeafRef&)
123 {
124 return "a leafref";
125 }
Jan Kundrát379bb572020-05-07 03:23:13 +0200126 std::string operator()(const yang::Empty&)
127 {
128 return "an empty leaf";
129 }
Václav Kubernát2984f442020-02-20 17:43:35 +0100130 std::string operator()(const yang::Union& type)
131 {
132 std::ostringstream ss;
133 std::transform(type.m_unionTypes.begin(), type.m_unionTypes.end(), std::experimental::make_ostream_joiner(ss, ", "), [this](const auto& unionType) {
Václav Kubernát13b23d72020-04-16 21:49:51 +0200134 return std::visit(*this, unionType.m_type);
Václav Kubernát2984f442020-02-20 17:43:35 +0100135 });
136 return ss.str();
137 }
Václav Kubernát3a99f002020-03-31 02:27:41 +0200138};
139
140std::string leafDataTypeToString(const yang::LeafDataType& type)
141{
142 return std::visit(impl_leafDataTypeToString{}, type);
Václav Kubernát0b0272f2018-06-13 14:13:08 +0200143}
Václav Kubernát744f57f2018-06-29 22:46:26 +0200144
Václav Kubernát2eaceb82018-10-08 19:56:30 +0200145std::string fullNodeName(const schemaPath_& location, const ModuleNodePair& pair)
Václav Kubernát744f57f2018-06-29 22:46:26 +0200146{
147 if (!pair.first) {
148 return location.m_nodes.at(0).m_prefix.value().m_name + ":" + pair.second;
149 } else {
150 return pair.first.value() + ":" + pair.second;
151 }
152}
Václav Kubernát2eaceb82018-10-08 19:56:30 +0200153
154std::string fullNodeName(const dataPath_& location, const ModuleNodePair& pair)
155{
156 return fullNodeName(dataPathToSchemaPath(location), pair);
157}
Václav Kubernát4108e0d2018-10-29 13:32:22 +0100158
Václav Kubernát9b725992019-05-29 16:39:47 +0200159struct leafDataToStringVisitor : boost::static_visitor<std::string> {
160 std::string operator()(const enum_& data) const
161 {
162 return data.m_value;
163 }
164
165 std::string operator()(const binary_& data) const
166 {
167 return data.m_value;
168 }
169
Jan Kundrát379bb572020-05-07 03:23:13 +0200170 std::string operator()(const empty_) const
171 {
172 return "[empty]";
173 }
174
Václav Kubernát9b725992019-05-29 16:39:47 +0200175 std::string operator()(const identityRef_& data) const
176 {
Jan Kundrát0d8abd12020-05-07 02:00:14 +0200177 return data.m_prefix ? (data.m_prefix.value().m_name + ":" + data.m_value) : data.m_value;
Václav Kubernát9b725992019-05-29 16:39:47 +0200178 }
179
Václav Kubernát144729d2020-01-08 15:20:35 +0100180 std::string operator()(const special_& data) const
181 {
182 return specialValueToString(data);
183 }
184
Jan Kundrátc43acf72019-07-02 19:28:22 +0200185 std::string operator()(const std::string& data) const
186 {
187 return data;
188 }
189
Václav Kubernát8e121ff2019-10-15 15:47:45 +0200190 std::string operator()(const bool& data) const
191 {
192 if (data)
193 return "true";
194 else
195 return "false";
196 }
197
Václav Kubernát9b725992019-05-29 16:39:47 +0200198 template <typename T>
199 std::string operator()(const T& data) const
200 {
Jan Kundrátc43acf72019-07-02 19:28:22 +0200201 return std::to_string(data);
Václav Kubernát9b725992019-05-29 16:39:47 +0200202 }
203};
204
205std::string leafDataToString(const leaf_data_ value)
206{
207 return boost::apply_visitor(leafDataToStringVisitor(), value);
208}
Václav Kubernát3a823f42020-04-29 23:40:21 +0200209
210struct getSchemaPathVisitor : boost::static_visitor<schemaPath_> {
211 schemaPath_ operator()(const dataPath_& path) const
212 {
213 return dataPathToSchemaPath(path);
214 }
215
216 schemaPath_ operator()(const schemaPath_& path) const
217 {
218 return path;
219 }
220
221 [[noreturn]] schemaPath_ operator()([[maybe_unused]] const module_& path) const
222 {
223 throw std::logic_error("getSchemaPathVisitor: Tried getting a schema path from a module");
224 }
225};
226
227schemaPath_ anyPathToSchemaPath(const boost::variant<dataPath_, schemaPath_, module_>& path)
228{
229 return boost::apply_visitor(getSchemaPathVisitor(), path);
230}
Václav Kubernát5b8a8f32020-05-20 00:57:22 +0200231
232std::string stripLeafListValueFromPath(const std::string& path)
233{
234 auto res = path;
235 res.erase(res.find_last_of('['));
236 return res;
237}
Václav Kubernátbf65dd72020-05-28 02:32:31 +0200238
239std::string stripLastListInstanceFromPath(const std::string& path)
240{
241 auto res = path;
242 res.erase(res.find_first_of('[', res.find_last_of('/')));
243 return res;
244}
245
Václav Kubernát2c4778b2020-06-18 11:55:20 +0200246std::string instanceToString(const ListInstance& instance, const std::optional<std::string>& modName)
Václav Kubernátbf65dd72020-05-28 02:32:31 +0200247{
248 std::string instanceStr;
Václav Kubernát2c4778b2020-06-18 11:55:20 +0200249 auto modulePrefix = modName ? *modName + ":" : "";
Václav Kubernátbf65dd72020-05-28 02:32:31 +0200250 for (const auto& [key, value] : instance) {
251 using namespace std::string_literals;
Václav Kubernát2c4778b2020-06-18 11:55:20 +0200252 instanceStr += "[" + modulePrefix + key + "=" + escapeListKeyString(leafDataToString(value)) + "]";
Václav Kubernátbf65dd72020-05-28 02:32:31 +0200253 }
254 return instanceStr;
255}