blob: d554cb95e87c19593af23dd64c450c6f9174fb14 [file] [log] [blame]
Václav Kubernátbddbb172018-06-13 16:27:39 +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
Václav Kubernát9456b5c2019-10-02 21:14:52 +02009#include <boost/algorithm/string/predicate.hpp>
Václav Kubernátbddbb172018-06-13 16:27:39 +020010#include "static_schema.hpp"
11#include "utils.hpp"
12
Václav Kubernátbddbb172018-06-13 16:27:39 +020013StaticSchema::StaticSchema()
14{
Václav Kubernátefcac932020-01-10 15:26:32 +010015 m_nodes.emplace("/", std::unordered_map<std::string, NodeType>());
Václav Kubernátbddbb172018-06-13 16:27:39 +020016}
17
18const std::unordered_map<std::string, NodeType>& StaticSchema::children(const std::string& name) const
19{
20 return m_nodes.at(name);
21}
22
Václav Kubernát744f57f2018-06-29 22:46:26 +020023bool StaticSchema::nodeExists(const std::string& location, const std::string& node) const
Václav Kubernátbddbb172018-06-13 16:27:39 +020024{
Václav Kubernát744f57f2018-06-29 22:46:26 +020025 if (node.empty())
Václav Kubernátbddbb172018-06-13 16:27:39 +020026 return true;
27 const auto& childrenRef = children(location);
28
Václav Kubernát744f57f2018-06-29 22:46:26 +020029 return childrenRef.find(node) != childrenRef.end();
Václav Kubernátbddbb172018-06-13 16:27:39 +020030}
31
Václav Kubernát75877de2019-11-20 17:43:02 +010032bool StaticSchema::isModule(const std::string& name) const
Václav Kubernátbddbb172018-06-13 16:27:39 +020033{
Václav Kubernát744f57f2018-06-29 22:46:26 +020034 return m_modules.find(name) != m_modules.end();
35}
36
Václav Kubernátbddbb172018-06-13 16:27:39 +020037void StaticSchema::addContainer(const std::string& location, const std::string& name, yang::ContainerTraits isPresence)
38{
39 m_nodes.at(location).emplace(name, yang::container{isPresence});
40
41 //create a new set of children for the new node
42 std::string key = joinPaths(location, name);
43 m_nodes.emplace(key, std::unordered_map<std::string, NodeType>());
44}
45
Václav Kubernát2eaceb82018-10-08 19:56:30 +020046bool StaticSchema::listHasKey(const schemaPath_& location, const ModuleNodePair& node, const std::string& key) const
Václav Kubernátbddbb172018-06-13 16:27:39 +020047{
Václav Kubernátefcac932020-01-10 15:26:32 +010048 std::string locationString = pathToSchemaString(location, Prefixes::Always);
Václav Kubernát744f57f2018-06-29 22:46:26 +020049 assert(isList(location, node));
Václav Kubernátbddbb172018-06-13 16:27:39 +020050
Václav Kubernát744f57f2018-06-29 22:46:26 +020051 const auto& child = children(locationString).at(fullNodeName(location, node));
Václav Kubernátbddbb172018-06-13 16:27:39 +020052 const auto& list = boost::get<yang::list>(child);
53 return list.m_keys.find(key) != list.m_keys.end();
54}
55
Václav Kubernát2eaceb82018-10-08 19:56:30 +020056const std::set<std::string> StaticSchema::listKeys(const schemaPath_& location, const ModuleNodePair& node) const
Václav Kubernátbddbb172018-06-13 16:27:39 +020057{
Václav Kubernátefcac932020-01-10 15:26:32 +010058 std::string locationString = pathToSchemaString(location, Prefixes::Always);
Václav Kubernát744f57f2018-06-29 22:46:26 +020059 assert(isList(location, node));
Václav Kubernátbddbb172018-06-13 16:27:39 +020060
Václav Kubernát744f57f2018-06-29 22:46:26 +020061 const auto& child = children(locationString).at(fullNodeName(location, node));
Václav Kubernátbddbb172018-06-13 16:27:39 +020062 const auto& list = boost::get<yang::list>(child);
63 return list.m_keys;
64}
65
Václav Kubernátbddbb172018-06-13 16:27:39 +020066void StaticSchema::addList(const std::string& location, const std::string& name, const std::set<std::string>& keys)
67{
68 m_nodes.at(location).emplace(name, yang::list{keys});
69
Václav Kubernát1446fe12019-10-02 19:32:51 +020070 std::string key = joinPaths(location, name);
71 m_nodes.emplace(key, std::unordered_map<std::string, NodeType>());
Václav Kubernátbddbb172018-06-13 16:27:39 +020072}
73
Václav Kubernát3a99f002020-03-31 02:27:41 +020074std::set<identityRef_> StaticSchema::validIdentities(std::string_view module, std::string_view value)
Václav Kubernátbddbb172018-06-13 16:27:39 +020075{
Václav Kubernát3a99f002020-03-31 02:27:41 +020076 std::set<ModuleValuePair> identities;
77 getIdentSet(ModuleNodePair{boost::optional<std::string>{module}, value}, identities);
78 std::set<identityRef_> res;
79
80 std::transform(identities.begin(), identities.end(), std::inserter(res, res.end()), [](const auto& identity) {
81 return identityRef_{*identity.first, identity.second};
82 });
83
84 return res;
Václav Kubernátbddbb172018-06-13 16:27:39 +020085}
86
Václav Kubernát3a99f002020-03-31 02:27:41 +020087void StaticSchema::addLeaf(const std::string& location, const std::string& name, const yang::LeafDataType& type)
Václav Kubernátbddbb172018-06-13 16:27:39 +020088{
Václav Kubernát13b23d72020-04-16 21:49:51 +020089 m_nodes.at(location).emplace(name, yang::leaf{yang::TypeInfo{type, std::nullopt}});
Václav Kubernáte69133a2019-11-01 19:01:34 +010090 std::string key = joinPaths(location, name);
91 m_nodes.emplace(key, std::unordered_map<std::string, NodeType>());
Václav Kubernát6a8d1d92019-04-24 20:30:36 +020092}
93
Václav Kubernát744f57f2018-06-29 22:46:26 +020094void StaticSchema::addModule(const std::string& name)
Václav Kubernátbddbb172018-06-13 16:27:39 +020095{
Václav Kubernát744f57f2018-06-29 22:46:26 +020096 m_modules.emplace(name);
97}
Václav Kubernátbddbb172018-06-13 16:27:39 +020098
Václav Kubernáteeb38842019-03-20 19:46:05 +010099void StaticSchema::addIdentity(const std::optional<ModuleValuePair>& base, const ModuleValuePair& name)
100{
101 if (base)
102 m_identities.at(base.value()).emplace(name);
103
104 m_identities.emplace(name, std::set<ModuleValuePair>());
105}
Václav Kubernát744f57f2018-06-29 22:46:26 +0200106
Václav Kubernáteeb38842019-03-20 19:46:05 +0100107void StaticSchema::getIdentSet(const ModuleValuePair& ident, std::set<ModuleValuePair>& res) const
108{
109 res.insert(ident);
110 auto derivedIdentities = m_identities.at(ident);
111 for (auto it : derivedIdentities) {
112 getIdentSet(it, res);
113 }
114}
115
Václav Kubernát6a8d1d92019-04-24 20:30:36 +0200116std::string lastNodeOfSchemaPath(const std::string& path)
117{
118 std::string res = path;
Václav Kubernát2d7b05c2020-04-05 14:02:37 +0200119 if (auto pos = res.find_last_of('/'); pos != res.npos) {
120 res.erase(0, pos + 1);
Václav Kubernátefcac932020-01-10 15:26:32 +0100121 }
Václav Kubernát6a8d1d92019-04-24 20:30:36 +0200122 return res;
123}
124
Václav Kubernát13b23d72020-04-16 21:49:51 +0200125yang::TypeInfo StaticSchema::leafType(const schemaPath_& location, const ModuleNodePair& node) const
Václav Kubernátbddbb172018-06-13 16:27:39 +0200126{
Václav Kubernátefcac932020-01-10 15:26:32 +0100127 std::string locationString = pathToSchemaString(location, Prefixes::Always);
Václav Kubernát744f57f2018-06-29 22:46:26 +0200128 return boost::get<yang::leaf>(children(locationString).at(fullNodeName(location, node))).m_type;
129}
130
Václav Kubernát13b23d72020-04-16 21:49:51 +0200131yang::TypeInfo StaticSchema::leafType(const std::string& path) const
Václav Kubernát9bf36852020-02-18 17:47:56 +0100132{
Václav Kubernát3a99f002020-03-31 02:27:41 +0200133 auto locationString = stripLastNodeFromPath(path);
134 auto node = lastNodeOfSchemaPath(path);
135 return boost::get<yang::leaf>(children(locationString).at(node)).m_type;
Václav Kubernát989b5de2019-02-20 16:28:35 +0100136}
137
Václav Kubernát95b08872020-04-28 01:04:17 +0200138ModuleNodePair splitModuleNode(const std::string& input)
139{
140 auto colonLocation = input.find_first_of(':');
141 if (colonLocation != std::string::npos) {
142 return ModuleNodePair{input.substr(0, colonLocation), input.substr(colonLocation + 1)};
143 }
144 throw std::logic_error("Tried to split a string without a colon (StaticSchema node names should always be stored with prefixes)");
145}
146
147std::set<ModuleNodePair> StaticSchema::availableNodes(const boost::variant<dataPath_, schemaPath_, module_>& path, const Recursion recursion) const
Václav Kubernát744f57f2018-06-29 22:46:26 +0200148{
Václav Kubernát3a823f42020-04-29 23:40:21 +0200149 if (recursion == Recursion::Recursive) {
150 throw std::logic_error("Recursive StaticSchema::availableNodes is not implemented. It shouldn't be used in tests.");
151 }
152
Václav Kubernát95b08872020-04-28 01:04:17 +0200153 std::set<ModuleNodePair> res;
Václav Kubernát3a823f42020-04-29 23:40:21 +0200154 if (path.type() == typeid(module_)) {
155 auto topLevelNodes = m_nodes.at("");
156 auto modulePlusColon = boost::get<module_>(path).m_name + ":";
157 for (const auto& it : topLevelNodes) {
158 if (boost::algorithm::starts_with(it.first, modulePlusColon)) {
Václav Kubernát95b08872020-04-28 01:04:17 +0200159 res.insert(splitModuleNode(it.first));
Václav Kubernát3a823f42020-04-29 23:40:21 +0200160 }
161 }
162 return res;
163 }
164
Václav Kubernáte2d629f2020-04-28 11:01:54 +0200165 auto getTopLevelModule = [] (const auto& path) -> boost::optional<std::string> {
166 if (!path.m_nodes.empty()) {
167 return path.m_nodes.begin()->m_prefix.flat_map([] (const auto& module) {return boost::optional<std::string>(module.m_name);});
168 }
169
170 return boost::none;
171 };
172
173 std::string locationString;
174 boost::optional<std::string> topLevelModule;
175 if (path.type() == typeid(schemaPath_)) {
176 locationString = pathToSchemaString(boost::get<schemaPath_>(path), Prefixes::Always);
177 topLevelModule = getTopLevelModule(boost::get<schemaPath_>(path));
178 } else {
179 locationString = pathToSchemaString(boost::get<dataPath_>(path), Prefixes::Always);
180 topLevelModule = getTopLevelModule(boost::get<dataPath_>(path));
181 }
Václav Kubernát744f57f2018-06-29 22:46:26 +0200182
183 auto childrenRef = children(locationString);
184
Václav Kubernáte2d629f2020-04-28 11:01:54 +0200185 std::transform(childrenRef.begin(), childrenRef.end(), std::inserter(res, res.end()), [path, topLevelModule](const auto& it) {
186 auto res = splitModuleNode(it.first);
187 if (topLevelModule == res.first) {
188 res.first = boost::none;
189 }
190 return res;
Václav Kubernát95b08872020-04-28 01:04:17 +0200191 });
Václav Kubernát744f57f2018-06-29 22:46:26 +0200192 return res;
Václav Kubernátbddbb172018-06-13 16:27:39 +0200193}
Václav Kubernát9456b5c2019-10-02 21:14:52 +0200194
Václav Kubernát34ee85a2020-02-18 17:12:12 +0100195yang::NodeTypes StaticSchema::nodeType(const schemaPath_& location, const ModuleNodePair& node) const
196{
197 std::string locationString = pathToSchemaString(location, Prefixes::Always);
198 auto fullName = fullNodeName(location, node);
199 try {
200 auto targetNode = children(locationString).at(fullName);
201
202 if (targetNode.type() == typeid(yang::container)) {
203 if (boost::get<yang::container>(targetNode).m_presence == yang::ContainerTraits::Presence) {
204 return yang::NodeTypes::PresenceContainer;
205 }
206 return yang::NodeTypes::Container;
207 }
208
209 if (targetNode.type() == typeid(yang::list)) {
210 return yang::NodeTypes::List;
211 }
212
213 if (targetNode.type() == typeid(yang::leaf)) {
214 return yang::NodeTypes::Leaf;
215 }
216
217 throw std::runtime_error{"YangSchema::nodeType: unsupported type"};
218
219 } catch (std::out_of_range&) {
220 throw InvalidNodeException();
221 }
222}
223
Václav Kubernát1e09bd62020-02-17 15:13:38 +0100224std::optional<std::string> StaticSchema::description([[maybe_unused]] const std::string& path) const
225{
226 throw std::runtime_error{"StaticSchema::description not implemented"};
227}
228
Václav Kubernáta1c4c9e2020-04-22 00:37:52 +0200229yang::Status StaticSchema::status([[maybe_unused]] const std::string& location) const
230{
231 throw std::runtime_error{"Internal error: StaticSchema::status(std::string) not implemented. The tests should not have called this overload."};
232}
233
Václav Kubernát34ee85a2020-02-18 17:12:12 +0100234yang::NodeTypes StaticSchema::nodeType([[maybe_unused]] const std::string& path) const
235{
236 throw std::runtime_error{"Internal error: StaticSchema::nodeType(std::string) not implemented. The tests should not have called this overload."};
237}
Václav Kubernátad87ece2020-02-19 15:20:56 +0100238
Václav Kubernátbd5e3c22020-02-19 15:22:00 +0100239std::string StaticSchema::leafrefPath([[maybe_unused]] const std::string& leafrefPath) const
240{
241 throw std::runtime_error{"Internal error: StaticSchema::leafrefPath(std::string) not implemented. The tests should not have called this overload."};
242}
Václav Kubernátc3866792020-02-20 14:12:56 +0100243
244bool StaticSchema::leafIsKey([[maybe_unused]] const std::string& leafPath) const
245{
246 throw std::runtime_error{"Internal error: StaticSchema::leafIsKey(std::string) not implemented. The tests should not have called this overload."};
247}
Václav Kubernát6fcd0282020-02-21 16:33:08 +0100248
249std::optional<std::string> StaticSchema::leafTypeName([[maybe_unused]] const std::string& path) const
250{
251 throw std::runtime_error{"Internal error: StaticSchema::leafTypeName(std::string) not implemented. The tests should not have called this overload."};
252}
Václav Kubernát0599e9f2020-04-21 09:51:33 +0200253
254bool StaticSchema::isConfig([[maybe_unused]] const std::string& leafPath) const
255{
256 throw std::runtime_error{"Internal error: StaticSchema::isConfigLeaf(std::string) not implemented. The tests should not have called this overload."};
257}
Václav Kubernátb1a75c62020-04-21 15:20:16 +0200258
259std::optional<std::string> StaticSchema::defaultValue([[maybe_unused]] const std::string& leafPath) const
260{
261 throw std::runtime_error{"Internal error: StaticSchema::defaultValue(std::string) not implemented. The tests should not have called this overload."};
262}