blob: b134440092cc0f5b2f9be194e21986568ce1a522 [file] [log] [blame]
Václav Kubernát0d4db442018-07-18 17:18:43 +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
9#include <libyang/Libyang.hpp>
Václav Kubernátc31bd602019-03-07 11:44:48 +010010#include <libyang/Tree_Data.hpp>
Václav Kubernát0d4db442018-07-18 17:18:43 +020011#include <libyang/Tree_Schema.hpp>
12#include <string_view>
Václav Kubernát26b56082020-02-03 18:28:56 +010013#include "UniqueResource.hpp"
Václav Kubernát0d4db442018-07-18 17:18:43 +020014#include "utils.hpp"
15#include "yang_schema.hpp"
16
17class YangLoadError : public std::runtime_error {
18public:
19 using std::runtime_error::runtime_error;
20 ~YangLoadError() override = default;
21};
22
23class UnsupportedYangTypeException : public std::runtime_error {
24public:
25 using std::runtime_error::runtime_error;
26 ~UnsupportedYangTypeException() override = default;
27};
28
29class InvalidSchemaQueryException : public std::runtime_error {
30public:
31 using std::runtime_error::runtime_error;
32 ~InvalidSchemaQueryException() override = default;
33};
34
Václav Kubernát2eaceb82018-10-08 19:56:30 +020035template <typename T>
36std::string pathToYangAbsSchemPath(const T& path)
Václav Kubernát0d4db442018-07-18 17:18:43 +020037{
38 std::string res = "/";
39 std::string currentModule;
40
41 for (const auto& it : path.m_nodes) {
42 const auto name = nodeToSchemaString(it);
43
44 if (it.m_suffix.type() == typeid(module_)) {
45 currentModule = name;
46 continue;
47 } else {
48 res += currentModule + ":";
49 res += name + "/";
50 }
51 }
52
53 return res;
54}
55
56YangSchema::YangSchema()
Václav Kubernáta6c5fff2018-09-07 15:16:25 +020057 : m_context(std::make_shared<libyang::Context>(nullptr, LY_CTX_DISABLE_SEARCHDIRS | LY_CTX_DISABLE_SEARCHDIR_CWD))
Václav Kubernát0d4db442018-07-18 17:18:43 +020058{
Václav Kubernát0d4db442018-07-18 17:18:43 +020059}
60
Václav Kubernát1d50a5b2020-02-03 16:44:22 +010061YangSchema::YangSchema(std::shared_ptr<libyang::Context> lyCtx)
62 : m_context(lyCtx)
63{
64
65}
66
Václav Kubernát0d4db442018-07-18 17:18:43 +020067YangSchema::~YangSchema() = default;
68
69void YangSchema::addSchemaString(const char* schema)
70{
71 if (!m_context->parse_module_mem(schema, LYS_IN_YANG)) {
72 throw YangLoadError("Couldn't load schema");
73 }
74}
75
76void YangSchema::addSchemaDirectory(const char* directoryName)
77{
78 if (m_context->set_searchdir(directoryName)) {
79 throw YangLoadError("Couldn't add schema search directory");
80 }
81}
82
83void YangSchema::addSchemaFile(const char* filename)
84{
85 if (!m_context->parse_module_path(filename, LYS_IN_YANG)) {
86 throw YangLoadError("Couldn't load schema");
87 }
88}
89
Václav Kubernát75877de2019-11-20 17:43:02 +010090bool YangSchema::isModule(const std::string& name) const
Václav Kubernát0d4db442018-07-18 17:18:43 +020091{
92 const auto set = modules();
93 return set.find(name) != set.end();
94}
95
Václav Kubernát2eaceb82018-10-08 19:56:30 +020096bool YangSchema::listHasKey(const schemaPath_& location, const ModuleNodePair& node, const std::string& key) const
Václav Kubernát0d4db442018-07-18 17:18:43 +020097{
98 if (!isList(location, node))
99 return false;
100 const auto keys = listKeys(location, node);
101 return keys.find(key) != keys.end();
102}
103
Václav Kubernátc3866792020-02-20 14:12:56 +0100104bool YangSchema::leafIsKey(const std::string& leafPath) const
105{
106 auto node = getSchemaNode(leafPath);
107 if (!node || node->nodetype() != LYS_LEAF)
108 return false;
109
110 return libyang::Schema_Node_Leaf{node}.is_key().get();
111}
112
Václav Kubernát47a3f672019-11-08 15:42:43 +0100113libyang::S_Schema_Node YangSchema::impl_getSchemaNode(const std::string& node) const
Václav Kubernát0d4db442018-07-18 17:18:43 +0200114{
Václav Kubernátf2b91e02019-04-11 15:36:48 +0200115 // If no node is found find_path prints an error message, so we have to
116 // disable logging
117 // https://github.com/CESNET/libyang/issues/753
118 {
119 int oldOptions;
120 auto logBlocker = make_unique_resource(
121 [&oldOptions]() {
122 oldOptions = libyang::set_log_options(0);
123 },
124 [&oldOptions]() {
125 libyang::set_log_options(oldOptions);
126 });
Václav Kubernát47a3f672019-11-08 15:42:43 +0100127 return m_context->get_node(nullptr, node.c_str());
Václav Kubernátf2b91e02019-04-11 15:36:48 +0200128 }
Václav Kubernát0d4db442018-07-18 17:18:43 +0200129}
130
Václav Kubernát47a3f672019-11-08 15:42:43 +0100131
132libyang::S_Schema_Node YangSchema::getSchemaNode(const std::string& node) const
133{
134 return impl_getSchemaNode(node);
135}
136
137libyang::S_Schema_Node YangSchema::getSchemaNode(const schemaPath_& location, const ModuleNodePair& node) const
138{
Václav Kubernátefcac932020-01-10 15:26:32 +0100139 std::string absPath = joinPaths(pathToSchemaString(location, Prefixes::Always), fullNodeName(location, node));
Václav Kubernát47a3f672019-11-08 15:42:43 +0100140
141 return impl_getSchemaNode(absPath);
142}
143
Václav Kubernát2eaceb82018-10-08 19:56:30 +0200144const std::set<std::string> YangSchema::listKeys(const schemaPath_& location, const ModuleNodePair& node) const
Václav Kubernát0d4db442018-07-18 17:18:43 +0200145{
146 std::set<std::string> keys;
147 if (!isList(location, node))
148 return keys;
Jan Kundrát4ed0e9f2018-08-23 16:56:58 +0200149 libyang::Schema_Node_List list(getSchemaNode(location, node));
Jan Kundrát4030b772018-08-23 15:54:56 +0200150 const auto& keysVec = list.keys();
Václav Kubernát0d4db442018-07-18 17:18:43 +0200151
Václav Kubernát90de9502019-11-20 17:19:44 +0100152 std::transform(keysVec.begin(), keysVec.end(), std::inserter(keys, keys.begin()), [](const auto& it) { return it->name(); });
Václav Kubernát0d4db442018-07-18 17:18:43 +0200153 return keys;
154}
155
Václav Kubernát3a99f002020-03-31 02:27:41 +0200156namespace {
Václav Kubernát2984f442020-02-20 17:43:35 +0100157std::set<enum_> enumValues(const libyang::S_Type& typeArg)
Václav Kubernát0d4db442018-07-18 17:18:43 +0200158{
Václav Kubernát2984f442020-02-20 17:43:35 +0100159 auto type = typeArg;
Václav Kubernát3a99f002020-03-31 02:27:41 +0200160 auto enm = type->info()->enums()->enm();
161 // The enum can be a derived type and enm() only returns values,
162 // if that specific typedef changed the possible values. So we go
163 // up the hierarchy until we find a typedef that defined these values.
164 while (enm.empty()) {
165 type = type->der()->type();
166 enm = type->info()->enums()->enm();
Václav Kubernát6a8d1d92019-04-24 20:30:36 +0200167 }
Václav Kubernát3a99f002020-03-31 02:27:41 +0200168
169 std::vector<libyang::S_Type_Enum> enabled;
170 std::copy_if(enm.begin(), enm.end(), std::back_inserter(enabled), [](const libyang::S_Type_Enum& it) {
171 auto iffeatures = it->iffeature();
172 return std::all_of(iffeatures.begin(), iffeatures.end(), [](auto it) { return it->value(); });
173 });
174
175 std::set<enum_> enumSet;
176 std::transform(enabled.begin(), enabled.end(), std::inserter(enumSet, enumSet.end()), [](auto it) { return enum_{it->name()}; });
177 return enumSet;
Václav Kubernát6a8d1d92019-04-24 20:30:36 +0200178}
179
Václav Kubernát2984f442020-02-20 17:43:35 +0100180std::set<identityRef_> validIdentities(const libyang::S_Type& type)
Václav Kubernát3a99f002020-03-31 02:27:41 +0200181{
182 std::set<identityRef_> identSet;
183
184 // auto topLevelModule = leaf->module();
185
Václav Kubernát2984f442020-02-20 17:43:35 +0100186 auto info = type->info();
Václav Kubernát3a99f002020-03-31 02:27:41 +0200187 for (auto base : info->ident()->ref()) { // Iterate over all bases
188 identSet.emplace(base->module()->name(), base->name());
189 // Iterate over derived identities (this is recursive!)
190 for (auto derived : base->der()->schema()) {
191 identSet.emplace(derived->module()->name(), derived->name());
192 }
193 }
194
195 return identSet;
196}
197
Václav Kubernát2984f442020-02-20 17:43:35 +0100198std::string leafrefPath(const libyang::S_Type& type)
Václav Kubernát3a99f002020-03-31 02:27:41 +0200199{
Václav Kubernát2984f442020-02-20 17:43:35 +0100200 return type->info()->lref()->target()->path(LYS_PATH_FIRST_PREFIX);
Václav Kubernát3a99f002020-03-31 02:27:41 +0200201}
202}
203
Václav Kubernát13b23d72020-04-16 21:49:51 +0200204yang::TypeInfo YangSchema::impl_leafType(const libyang::S_Schema_Node& node) const
Václav Kubernát6a8d1d92019-04-24 20:30:36 +0200205{
206 using namespace std::string_literals;
Václav Kubernát3a99f002020-03-31 02:27:41 +0200207 auto leaf = std::make_shared<libyang::Schema_Node_Leaf>(node);
Václav Kubernát13b23d72020-04-16 21:49:51 +0200208 auto leafUnits = leaf->units();
209 std::function<yang::TypeInfo(std::shared_ptr<libyang::Type>)> resolveType;
210 resolveType = [this, &resolveType, leaf, leafUnits] (std::shared_ptr<libyang::Type> type) -> yang::TypeInfo {
211 yang::LeafDataType resType;
Václav Kubernát2984f442020-02-20 17:43:35 +0100212 switch (type->base()) {
213 case LY_TYPE_STRING:
Václav Kubernát13b23d72020-04-16 21:49:51 +0200214 resType.emplace<yang::String>();
215 break;
Václav Kubernát2984f442020-02-20 17:43:35 +0100216 case LY_TYPE_DEC64:
Václav Kubernát13b23d72020-04-16 21:49:51 +0200217 resType.emplace<yang::Decimal>();
218 break;
Václav Kubernát2984f442020-02-20 17:43:35 +0100219 case LY_TYPE_BOOL:
Václav Kubernát13b23d72020-04-16 21:49:51 +0200220 resType.emplace<yang::Bool>();
221 break;
Václav Kubernát2984f442020-02-20 17:43:35 +0100222 case LY_TYPE_INT8:
Václav Kubernát13b23d72020-04-16 21:49:51 +0200223 resType.emplace<yang::Int8>();
224 break;
Václav Kubernát2984f442020-02-20 17:43:35 +0100225 case LY_TYPE_INT16:
Václav Kubernát13b23d72020-04-16 21:49:51 +0200226 resType.emplace<yang::Int16>();
227 break;
Václav Kubernát2984f442020-02-20 17:43:35 +0100228 case LY_TYPE_INT32:
Václav Kubernát13b23d72020-04-16 21:49:51 +0200229 resType.emplace<yang::Int32>();
230 break;
Václav Kubernát2984f442020-02-20 17:43:35 +0100231 case LY_TYPE_INT64:
Václav Kubernát13b23d72020-04-16 21:49:51 +0200232 resType.emplace<yang::Int64>();
233 break;
Václav Kubernát2984f442020-02-20 17:43:35 +0100234 case LY_TYPE_UINT8:
Václav Kubernát13b23d72020-04-16 21:49:51 +0200235 resType.emplace<yang::Uint8>();
236 break;
Václav Kubernát2984f442020-02-20 17:43:35 +0100237 case LY_TYPE_UINT16:
Václav Kubernát13b23d72020-04-16 21:49:51 +0200238 resType.emplace<yang::Uint16>();
239 break;
Václav Kubernát2984f442020-02-20 17:43:35 +0100240 case LY_TYPE_UINT32:
Václav Kubernát13b23d72020-04-16 21:49:51 +0200241 resType.emplace<yang::Uint32>();
242 break;
Václav Kubernát2984f442020-02-20 17:43:35 +0100243 case LY_TYPE_UINT64:
Václav Kubernát13b23d72020-04-16 21:49:51 +0200244 resType.emplace<yang::Uint64>();
245 break;
Václav Kubernát2984f442020-02-20 17:43:35 +0100246 case LY_TYPE_BINARY:
Václav Kubernát13b23d72020-04-16 21:49:51 +0200247 resType.emplace<yang::Binary>();
248 break;
Václav Kubernát2984f442020-02-20 17:43:35 +0100249 case LY_TYPE_ENUM:
Václav Kubernát13b23d72020-04-16 21:49:51 +0200250 resType.emplace<yang::Enum>(enumValues(type));
251 break;
Václav Kubernát2984f442020-02-20 17:43:35 +0100252 case LY_TYPE_IDENT:
Václav Kubernát13b23d72020-04-16 21:49:51 +0200253 resType.emplace<yang::IdentityRef>(validIdentities(type));
254 break;
Václav Kubernát2984f442020-02-20 17:43:35 +0100255 case LY_TYPE_LEAFREF:
Václav Kubernát13b23d72020-04-16 21:49:51 +0200256 resType.emplace<yang::LeafRef>(::leafrefPath(type), std::make_unique<yang::TypeInfo>(leafType(::leafrefPath(type))));
257 break;
Václav Kubernát2984f442020-02-20 17:43:35 +0100258 case LY_TYPE_UNION:
259 {
Václav Kubernát13b23d72020-04-16 21:49:51 +0200260 auto resUnion = yang::Union{};
Václav Kubernát2984f442020-02-20 17:43:35 +0100261 for (auto unionType : type->info()->uni()->types()) {
Václav Kubernát13b23d72020-04-16 21:49:51 +0200262 resUnion.m_unionTypes.push_back(resolveType(unionType));
Václav Kubernát2984f442020-02-20 17:43:35 +0100263 }
Václav Kubernát13b23d72020-04-16 21:49:51 +0200264 resType.emplace<yang::Union>(std::move(resUnion));
265 break;
Václav Kubernát2984f442020-02-20 17:43:35 +0100266 }
267 default:
268 using namespace std::string_literals;
269 throw UnsupportedYangTypeException("the type of "s + leaf->name() + " is not supported: " + std::to_string(leaf->type()->base()));
270 }
Václav Kubernát13b23d72020-04-16 21:49:51 +0200271
272 std::optional<std::string> resUnits;
273
274 if (leafUnits) {
275 resUnits = leafUnits;
276 } else {
277 for (auto parentTypedef = type->der(); parentTypedef; parentTypedef = parentTypedef->type()->der()) {
278 auto units = parentTypedef->units();
279 if (units) {
280 resUnits = units;
281 break;
282 }
283 }
284 }
285
286 return yang::TypeInfo(resType, resUnits);
287 };
Václav Kubernát2984f442020-02-20 17:43:35 +0100288 return resolveType(leaf->type());
Václav Kubernát6a8d1d92019-04-24 20:30:36 +0200289}
290
Václav Kubernát13b23d72020-04-16 21:49:51 +0200291yang::TypeInfo YangSchema::leafType(const schemaPath_& location, const ModuleNodePair& node) const
Václav Kubernát9bf36852020-02-18 17:47:56 +0100292{
293 return impl_leafType(getSchemaNode(location, node));
294}
295
Václav Kubernát13b23d72020-04-16 21:49:51 +0200296yang::TypeInfo YangSchema::leafType(const std::string& path) const
Václav Kubernát9bf36852020-02-18 17:47:56 +0100297{
298 return impl_leafType(getSchemaNode(path));
299}
Václav Kubernát6a8d1d92019-04-24 20:30:36 +0200300
Václav Kubernát6fcd0282020-02-21 16:33:08 +0100301std::optional<std::string> YangSchema::leafTypeName(const std::string& path) const
302{
303 libyang::Schema_Node_Leaf leaf(getSchemaNode(path));
304 return leaf.type()->der().get() ? std::optional{leaf.type()->der()->name()} : std::nullopt;
305}
306
Václav Kubernátbd5e3c22020-02-19 15:22:00 +0100307std::string YangSchema::leafrefPath(const std::string& leafrefPath) const
308{
309 using namespace std::string_literals;
310 libyang::Schema_Node_Leaf leaf(getSchemaNode(leafrefPath));
311 return leaf.type()->info()->lref()->target()->path(LYS_PATH_FIRST_PREFIX);
312}
Václav Kubernát0d4db442018-07-18 17:18:43 +0200313
314std::set<std::string> YangSchema::modules() const
315{
Jan Kundrát4030b772018-08-23 15:54:56 +0200316 const auto& modules = m_context->get_module_iter();
Václav Kubernát0d4db442018-07-18 17:18:43 +0200317
318 std::set<std::string> res;
Václav Kubernát90de9502019-11-20 17:19:44 +0100319 std::transform(modules.begin(), modules.end(), std::inserter(res, res.end()), [](const auto module) { return module->name(); });
Václav Kubernát0d4db442018-07-18 17:18:43 +0200320 return res;
321}
322
Václav Kubernát2eaceb82018-10-08 19:56:30 +0200323std::set<std::string> YangSchema::childNodes(const schemaPath_& path, const Recursion recursion) const
Václav Kubernát0d4db442018-07-18 17:18:43 +0200324{
325 using namespace std::string_view_literals;
326 std::set<std::string> res;
Václav Kubernáte7d4aea2018-09-11 18:15:48 +0200327 std::vector<libyang::S_Schema_Node> nodes;
328
Václav Kubernát0d4db442018-07-18 17:18:43 +0200329 if (path.m_nodes.empty()) {
Václav Kubernáte7d4aea2018-09-11 18:15:48 +0200330 nodes = m_context->data_instantiables(0);
Václav Kubernát0d4db442018-07-18 17:18:43 +0200331 } else {
Václav Kubernátefcac932020-01-10 15:26:32 +0100332 const auto pathString = pathToSchemaString(path, Prefixes::Always);
333 const auto node = getSchemaNode(pathString);
Václav Kubernát47a3f672019-11-08 15:42:43 +0100334 nodes = node->child_instantiables(0);
Václav Kubernát0d4db442018-07-18 17:18:43 +0200335 }
Václav Kubernáte7d4aea2018-09-11 18:15:48 +0200336
Václav Kubernátef085742020-04-21 09:28:44 +0200337 for (const auto& node : nodes) {
Václav Kubernáte7d4aea2018-09-11 18:15:48 +0200338 if (node->module()->name() == "ietf-yang-library"sv)
Václav Kubernát89728d82018-09-13 16:28:28 +0200339 continue;
Václav Kubernátfa81c8c2020-02-13 17:22:46 +0100340 // FIXME: This is a temporary fix to filter out RPC nodes in
341 // tab-completion. The method will have to be changed/reworked when RPC
342 // support gets added.
343 if (node->nodetype() == LYS_RPC)
344 continue;
Václav Kubernáte7d4aea2018-09-11 18:15:48 +0200345 if (recursion == Recursion::Recursive) {
346 for (auto it : node->tree_dfs()) {
347 res.insert(it->path(LYS_PATH_FIRST_PREFIX));
348 }
349 } else {
Václav Kubernát4f77a252019-02-19 16:51:30 +0100350 std::string toInsert;
351 if (path.m_nodes.empty() || path.m_nodes.front().m_prefix.get().m_name != node->module()->name()) {
352 toInsert += node->module()->name();
353 toInsert += ":";
354 }
355 toInsert += node->name();
356 res.insert(toInsert);
Václav Kubernáte7d4aea2018-09-11 18:15:48 +0200357 }
358 }
359
Václav Kubernát0d4db442018-07-18 17:18:43 +0200360 return res;
361}
Václav Kubernáta6c5fff2018-09-07 15:16:25 +0200362
Václav Kubernát9456b5c2019-10-02 21:14:52 +0200363std::set<std::string> YangSchema::moduleNodes(const module_& module, const Recursion recursion) const
364{
365 std::set<std::string> res;
366 const auto yangModule = m_context->get_module(module.m_name.c_str());
367
368 std::vector<libyang::S_Schema_Node> nodes;
369
Václav Kubernátef085742020-04-21 09:28:44 +0200370 for (const auto& node : yangModule->data_instantiables(0)) {
Václav Kubernát9456b5c2019-10-02 21:14:52 +0200371 if (recursion == Recursion::Recursive) {
Václav Kubernátef085742020-04-21 09:28:44 +0200372 for (const auto& it : node->tree_dfs()) {
Václav Kubernát9456b5c2019-10-02 21:14:52 +0200373 res.insert(it->path(LYS_PATH_FIRST_PREFIX));
374 }
375 } else {
376 res.insert(module.m_name + ":" + node->name());
377 }
378 }
379
380 return res;
381}
382
Václav Kubernáta6c5fff2018-09-07 15:16:25 +0200383void YangSchema::loadModule(const std::string& moduleName)
384{
385 m_context->load_module(moduleName.c_str());
386}
387
Václav Kubernátbf9c6112019-11-04 16:03:35 +0100388void YangSchema::enableFeature(const std::string& moduleName, const std::string& featureName)
389{
390 m_context->get_module(moduleName.c_str())->feature_enable(featureName.c_str());
391}
392
Václav Kubernátb52dc252019-12-04 13:03:39 +0100393void YangSchema::registerModuleCallback(const std::function<std::string(const char*, const char*, const char*, const char*)>& clb)
Václav Kubernáta6c5fff2018-09-07 15:16:25 +0200394{
395 auto lambda = [clb](const char* mod_name, const char* mod_revision, const char* submod_name, const char* submod_revision) {
396 (void)submod_revision;
Václav Kubernátb52dc252019-12-04 13:03:39 +0100397 auto moduleSource = clb(mod_name, mod_revision, submod_name, submod_revision);
Václav Kubernáta6c5fff2018-09-07 15:16:25 +0200398 if (moduleSource.empty()) {
399 return libyang::Context::mod_missing_cb_return{LYS_IN_YANG, nullptr};
400 }
401 return libyang::Context::mod_missing_cb_return{LYS_IN_YANG, strdup(moduleSource.c_str())};
402 };
403
404 auto deleter = [](void* data) {
405 free(data);
406 };
407 m_context->add_missing_module_callback(lambda, deleter);
408}
Václav Kubernátc31bd602019-03-07 11:44:48 +0100409
410std::shared_ptr<libyang::Data_Node> YangSchema::dataNodeFromPath(const std::string& path, const std::optional<const std::string> value) const
411{
412 return std::make_shared<libyang::Data_Node>(m_context,
413 path.c_str(),
414 value ? value.value().c_str() : nullptr,
415 LYD_ANYDATA_CONSTSTRING,
Václav Kubernátab612e92019-11-26 19:51:31 +0100416 LYD_PATH_OPT_EDIT);
Václav Kubernátc31bd602019-03-07 11:44:48 +0100417}
418
419std::shared_ptr<libyang::Module> YangSchema::getYangModule(const std::string& name)
420{
421 return m_context->get_module(name.c_str(), nullptr, 0);
422}
Václav Kubernát34ee85a2020-02-18 17:12:12 +0100423
424namespace {
425yang::NodeTypes impl_nodeType(const libyang::S_Schema_Node& node)
426{
427 if (!node) {
428 throw InvalidNodeException();
429 }
430 switch (node->nodetype()) {
431 case LYS_CONTAINER:
432 return libyang::Schema_Node_Container{node}.presence() ? yang::NodeTypes::PresenceContainer : yang::NodeTypes::Container;
433 case LYS_LEAF:
434 return yang::NodeTypes::Leaf;
435 case LYS_LIST:
436 return yang::NodeTypes::List;
437 default:
Václav Kubernát2a141392020-02-18 17:12:32 +0100438 throw InvalidNodeException(); // FIXME: Implement all types.
Václav Kubernát34ee85a2020-02-18 17:12:12 +0100439 }
440}
441}
442
443yang::NodeTypes YangSchema::nodeType(const schemaPath_& location, const ModuleNodePair& node) const
444{
445 return impl_nodeType(getSchemaNode(location, node));
446}
447
448yang::NodeTypes YangSchema::nodeType(const std::string& path) const
449{
450 return impl_nodeType(getSchemaNode(path));
451}
Václav Kubernát1e09bd62020-02-17 15:13:38 +0100452
453std::optional<std::string> YangSchema::description(const std::string& path) const
454{
455 auto node = getSchemaNode(path.c_str());
456 return node->dsc() ? std::optional{node->dsc()} : std::nullopt;
457}
Václav Kubernát0599e9f2020-04-21 09:51:33 +0200458
Václav Kubernáta1c4c9e2020-04-22 00:37:52 +0200459yang::Status YangSchema::status(const std::string& location) const
460{
461 auto node = getSchemaNode(location.c_str());
462 if (node->flags() & LYS_STATUS_DEPRC) {
463 return yang::Status::Deprecated;
464 } else if (node->flags() & LYS_STATUS_OBSLT) {
465 return yang::Status::Obsolete;
466 } else {
467 return yang::Status::Current;
468 }
469}
470
Václav Kubernát0599e9f2020-04-21 09:51:33 +0200471bool YangSchema::isConfig(const std::string& path) const
472{
473 return getSchemaNode(path.c_str())->flags() & LYS_CONFIG_W;
474}
Václav Kubernátb1a75c62020-04-21 15:20:16 +0200475
476std::optional<std::string> YangSchema::defaultValue(const std::string& leafPath) const
477{
478 libyang::Schema_Node_Leaf leaf(getSchemaNode(leafPath));
479
480 if (auto leafDefault = leaf.dflt()) {
481 return leafDefault;
482 }
483
484 for (auto type = leaf.type()->der(); type != nullptr; type = type->type()->der()) {
485 if (auto defaultValue = type->dflt()) {
486 return defaultValue;
487 }
488 }
489
490 return std::nullopt;
491}