blob: 1ed25c7691107642c70d76dd3cf3482fc20b845a [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
Václav Kubernát3a99f002020-03-31 02:27:41 +020056struct impl_leafDataTypeToString {
57 std::string operator()(const yang::String)
58 {
Václav Kubernát0b0272f2018-06-13 14:13:08 +020059 return "a string";
Václav Kubernát0b0272f2018-06-13 14:13:08 +020060 }
Václav Kubernát3a99f002020-03-31 02:27:41 +020061 std::string operator()(const yang::Decimal)
62 {
63 return "a decimal";
64 }
65 std::string operator()(const yang::Bool)
66 {
67 return "a boolean";
68 }
69 std::string operator()(const yang::Int8)
70 {
71 return "an 8-bit integer";
72 }
73 std::string operator()(const yang::Uint8)
74 {
75 return "an 8-bit unsigned integer";
76 }
77 std::string operator()(const yang::Int16)
78 {
79 return "a 16-bit integer";
80 }
81 std::string operator()(const yang::Uint16)
82 {
83 return "a 16-bit unsigned integer";
84 }
85 std::string operator()(const yang::Int32)
86 {
87 return "a 32-bit integer";
88 }
89 std::string operator()(const yang::Uint32)
90 {
91 return "a 32-bit unsigned integer";
92 }
93 std::string operator()(const yang::Int64)
94 {
95 return "a 64-bit integer";
96 }
97 std::string operator()(const yang::Uint64)
98 {
99 return "a 64-bit unsigned integer";
100 }
101 std::string operator()(const yang::Binary)
102 {
103 return "a base64-encoded binary value";
104 }
105 std::string operator()(const yang::Enum&)
106 {
107 return "an enum";
108 }
109 std::string operator()(const yang::IdentityRef&)
110 {
111 return "an identity";
112 }
113 std::string operator()(const yang::LeafRef&)
114 {
115 return "a leafref";
116 }
Václav Kubernát2984f442020-02-20 17:43:35 +0100117 std::string operator()(const yang::Union& type)
118 {
119 std::ostringstream ss;
120 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 +0200121 return std::visit(*this, unionType.m_type);
Václav Kubernát2984f442020-02-20 17:43:35 +0100122 });
123 return ss.str();
124 }
Václav Kubernát3a99f002020-03-31 02:27:41 +0200125};
126
127std::string leafDataTypeToString(const yang::LeafDataType& type)
128{
129 return std::visit(impl_leafDataTypeToString{}, type);
Václav Kubernát0b0272f2018-06-13 14:13:08 +0200130}
Václav Kubernát744f57f2018-06-29 22:46:26 +0200131
Václav Kubernát2eaceb82018-10-08 19:56:30 +0200132std::string fullNodeName(const schemaPath_& location, const ModuleNodePair& pair)
Václav Kubernát744f57f2018-06-29 22:46:26 +0200133{
134 if (!pair.first) {
135 return location.m_nodes.at(0).m_prefix.value().m_name + ":" + pair.second;
136 } else {
137 return pair.first.value() + ":" + pair.second;
138 }
139}
Václav Kubernát2eaceb82018-10-08 19:56:30 +0200140
141std::string fullNodeName(const dataPath_& location, const ModuleNodePair& pair)
142{
143 return fullNodeName(dataPathToSchemaPath(location), pair);
144}
Václav Kubernát4108e0d2018-10-29 13:32:22 +0100145
Václav Kubernát9b725992019-05-29 16:39:47 +0200146struct leafDataToStringVisitor : boost::static_visitor<std::string> {
147 std::string operator()(const enum_& data) const
148 {
149 return data.m_value;
150 }
151
152 std::string operator()(const binary_& data) const
153 {
154 return data.m_value;
155 }
156
157 std::string operator()(const identityRef_& data) const
158 {
Václav Kubernátc31bd602019-03-07 11:44:48 +0100159 return data.m_prefix.value().m_name + ":" + data.m_value;
Václav Kubernát9b725992019-05-29 16:39:47 +0200160 }
161
Václav Kubernát144729d2020-01-08 15:20:35 +0100162 std::string operator()(const special_& data) const
163 {
164 return specialValueToString(data);
165 }
166
Jan Kundrátc43acf72019-07-02 19:28:22 +0200167 std::string operator()(const std::string& data) const
168 {
169 return data;
170 }
171
Václav Kubernát8e121ff2019-10-15 15:47:45 +0200172 std::string operator()(const bool& data) const
173 {
174 if (data)
175 return "true";
176 else
177 return "false";
178 }
179
Václav Kubernát9b725992019-05-29 16:39:47 +0200180 template <typename T>
181 std::string operator()(const T& data) const
182 {
Jan Kundrátc43acf72019-07-02 19:28:22 +0200183 return std::to_string(data);
Václav Kubernát9b725992019-05-29 16:39:47 +0200184 }
185};
186
187std::string leafDataToString(const leaf_data_ value)
188{
189 return boost::apply_visitor(leafDataToStringVisitor(), value);
190}
Václav Kubernát3a823f42020-04-29 23:40:21 +0200191
192struct getSchemaPathVisitor : boost::static_visitor<schemaPath_> {
193 schemaPath_ operator()(const dataPath_& path) const
194 {
195 return dataPathToSchemaPath(path);
196 }
197
198 schemaPath_ operator()(const schemaPath_& path) const
199 {
200 return path;
201 }
202
203 [[noreturn]] schemaPath_ operator()([[maybe_unused]] const module_& path) const
204 {
205 throw std::logic_error("getSchemaPathVisitor: Tried getting a schema path from a module");
206 }
207};
208
209schemaPath_ anyPathToSchemaPath(const boost::variant<dataPath_, schemaPath_, module_>& path)
210{
211 return boost::apply_visitor(getSchemaPathVisitor(), path);
212}