blob: dbfc64720cf7cac1ff1f64b5bbfe06c6054aa249 [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 }
Václav Kubernát2984f442020-02-20 17:43:35 +0100126 std::string operator()(const yang::Union& type)
127 {
128 std::ostringstream ss;
129 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 +0200130 return std::visit(*this, unionType.m_type);
Václav Kubernát2984f442020-02-20 17:43:35 +0100131 });
132 return ss.str();
133 }
Václav Kubernát3a99f002020-03-31 02:27:41 +0200134};
135
136std::string leafDataTypeToString(const yang::LeafDataType& type)
137{
138 return std::visit(impl_leafDataTypeToString{}, type);
Václav Kubernát0b0272f2018-06-13 14:13:08 +0200139}
Václav Kubernát744f57f2018-06-29 22:46:26 +0200140
Václav Kubernát2eaceb82018-10-08 19:56:30 +0200141std::string fullNodeName(const schemaPath_& location, const ModuleNodePair& pair)
Václav Kubernát744f57f2018-06-29 22:46:26 +0200142{
143 if (!pair.first) {
144 return location.m_nodes.at(0).m_prefix.value().m_name + ":" + pair.second;
145 } else {
146 return pair.first.value() + ":" + pair.second;
147 }
148}
Václav Kubernát2eaceb82018-10-08 19:56:30 +0200149
150std::string fullNodeName(const dataPath_& location, const ModuleNodePair& pair)
151{
152 return fullNodeName(dataPathToSchemaPath(location), pair);
153}
Václav Kubernát4108e0d2018-10-29 13:32:22 +0100154
Václav Kubernát9b725992019-05-29 16:39:47 +0200155struct leafDataToStringVisitor : boost::static_visitor<std::string> {
156 std::string operator()(const enum_& data) const
157 {
158 return data.m_value;
159 }
160
161 std::string operator()(const binary_& data) const
162 {
163 return data.m_value;
164 }
165
166 std::string operator()(const identityRef_& data) const
167 {
Václav Kubernátc31bd602019-03-07 11:44:48 +0100168 return data.m_prefix.value().m_name + ":" + data.m_value;
Václav Kubernát9b725992019-05-29 16:39:47 +0200169 }
170
Václav Kubernát144729d2020-01-08 15:20:35 +0100171 std::string operator()(const special_& data) const
172 {
173 return specialValueToString(data);
174 }
175
Jan Kundrátc43acf72019-07-02 19:28:22 +0200176 std::string operator()(const std::string& data) const
177 {
178 return data;
179 }
180
Václav Kubernát8e121ff2019-10-15 15:47:45 +0200181 std::string operator()(const bool& data) const
182 {
183 if (data)
184 return "true";
185 else
186 return "false";
187 }
188
Václav Kubernát9b725992019-05-29 16:39:47 +0200189 template <typename T>
190 std::string operator()(const T& data) const
191 {
Jan Kundrátc43acf72019-07-02 19:28:22 +0200192 return std::to_string(data);
Václav Kubernát9b725992019-05-29 16:39:47 +0200193 }
194};
195
196std::string leafDataToString(const leaf_data_ value)
197{
198 return boost::apply_visitor(leafDataToStringVisitor(), value);
199}
Václav Kubernát3a823f42020-04-29 23:40:21 +0200200
201struct getSchemaPathVisitor : boost::static_visitor<schemaPath_> {
202 schemaPath_ operator()(const dataPath_& path) const
203 {
204 return dataPathToSchemaPath(path);
205 }
206
207 schemaPath_ operator()(const schemaPath_& path) const
208 {
209 return path;
210 }
211
212 [[noreturn]] schemaPath_ operator()([[maybe_unused]] const module_& path) const
213 {
214 throw std::logic_error("getSchemaPathVisitor: Tried getting a schema path from a module");
215 }
216};
217
218schemaPath_ anyPathToSchemaPath(const boost::variant<dataPath_, schemaPath_, module_>& path)
219{
220 return boost::apply_visitor(getSchemaPathVisitor(), path);
221}