Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 1 | /* |
| 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át | c31bd60 | 2019-03-07 11:44:48 +0100 | [diff] [blame] | 10 | #include <libyang/Tree_Data.hpp> |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 11 | #include <libyang/Tree_Schema.hpp> |
| 12 | #include <string_view> |
Václav Kubernát | f2b91e0 | 2019-04-11 15:36:48 +0200 | [diff] [blame] | 13 | #include "UniqueResource.h" |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 14 | #include "utils.hpp" |
| 15 | #include "yang_schema.hpp" |
| 16 | |
| 17 | class YangLoadError : public std::runtime_error { |
| 18 | public: |
| 19 | using std::runtime_error::runtime_error; |
| 20 | ~YangLoadError() override = default; |
| 21 | }; |
| 22 | |
| 23 | class UnsupportedYangTypeException : public std::runtime_error { |
| 24 | public: |
| 25 | using std::runtime_error::runtime_error; |
| 26 | ~UnsupportedYangTypeException() override = default; |
| 27 | }; |
| 28 | |
| 29 | class InvalidSchemaQueryException : public std::runtime_error { |
| 30 | public: |
| 31 | using std::runtime_error::runtime_error; |
| 32 | ~InvalidSchemaQueryException() override = default; |
| 33 | }; |
| 34 | |
Václav Kubernát | 2eaceb8 | 2018-10-08 19:56:30 +0200 | [diff] [blame] | 35 | template <typename T> |
| 36 | std::string pathToYangAbsSchemPath(const T& path) |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 37 | { |
| 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 | |
| 56 | YangSchema::YangSchema() |
Václav Kubernát | a6c5fff | 2018-09-07 15:16:25 +0200 | [diff] [blame] | 57 | : m_context(std::make_shared<libyang::Context>(nullptr, LY_CTX_DISABLE_SEARCHDIRS | LY_CTX_DISABLE_SEARCHDIR_CWD)) |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 58 | { |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 59 | } |
| 60 | |
| 61 | YangSchema::~YangSchema() = default; |
| 62 | |
| 63 | void YangSchema::addSchemaString(const char* schema) |
| 64 | { |
| 65 | if (!m_context->parse_module_mem(schema, LYS_IN_YANG)) { |
| 66 | throw YangLoadError("Couldn't load schema"); |
| 67 | } |
| 68 | } |
| 69 | |
| 70 | void YangSchema::addSchemaDirectory(const char* directoryName) |
| 71 | { |
| 72 | if (m_context->set_searchdir(directoryName)) { |
| 73 | throw YangLoadError("Couldn't add schema search directory"); |
| 74 | } |
| 75 | } |
| 76 | |
| 77 | void YangSchema::addSchemaFile(const char* filename) |
| 78 | { |
| 79 | if (!m_context->parse_module_path(filename, LYS_IN_YANG)) { |
| 80 | throw YangLoadError("Couldn't load schema"); |
| 81 | } |
| 82 | } |
| 83 | |
Václav Kubernát | 2eaceb8 | 2018-10-08 19:56:30 +0200 | [diff] [blame] | 84 | bool YangSchema::isModule(const schemaPath_&, const std::string& name) const |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 85 | { |
| 86 | const auto set = modules(); |
| 87 | return set.find(name) != set.end(); |
| 88 | } |
| 89 | |
Václav Kubernát | 2eaceb8 | 2018-10-08 19:56:30 +0200 | [diff] [blame] | 90 | bool YangSchema::isContainer(const schemaPath_& location, const ModuleNodePair& node) const |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 91 | { |
| 92 | const auto schemaNode = getSchemaNode(location, node); |
| 93 | return schemaNode && schemaNode->nodetype() == LYS_CONTAINER; |
| 94 | } |
| 95 | |
Václav Kubernát | 2eaceb8 | 2018-10-08 19:56:30 +0200 | [diff] [blame] | 96 | bool YangSchema::isLeaf(const schemaPath_& location, const ModuleNodePair& node) const |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 97 | { |
| 98 | const auto schemaNode = getSchemaNode(location, node); |
| 99 | return schemaNode && schemaNode->nodetype() == LYS_LEAF; |
| 100 | } |
| 101 | |
Václav Kubernát | 2eaceb8 | 2018-10-08 19:56:30 +0200 | [diff] [blame] | 102 | bool YangSchema::isList(const schemaPath_& location, const ModuleNodePair& node) const |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 103 | { |
| 104 | const auto schemaNode = getSchemaNode(location, node); |
| 105 | return schemaNode && schemaNode->nodetype() == LYS_LIST; |
| 106 | } |
| 107 | |
Václav Kubernát | 2eaceb8 | 2018-10-08 19:56:30 +0200 | [diff] [blame] | 108 | bool YangSchema::isPresenceContainer(const schemaPath_& location, const ModuleNodePair& node) const |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 109 | { |
| 110 | if (!isContainer(location, node)) |
| 111 | return false; |
Jan Kundrát | 4ed0e9f | 2018-08-23 16:56:58 +0200 | [diff] [blame] | 112 | return libyang::Schema_Node_Container(getSchemaNode(location, node)).presence(); |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 113 | } |
| 114 | |
Václav Kubernát | 2eaceb8 | 2018-10-08 19:56:30 +0200 | [diff] [blame] | 115 | bool YangSchema::leafEnumHasValue(const schemaPath_& location, const ModuleNodePair& node, const std::string& value) const |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 116 | { |
Václav Kubernát | 989b5de | 2019-02-20 16:28:35 +0100 | [diff] [blame] | 117 | auto enums = enumValues(location, node); |
| 118 | |
| 119 | return std::any_of(enums.begin(), enums.end(), [=](const auto& x) { return x == value; }); |
| 120 | } |
| 121 | |
| 122 | const std::set<std::string> YangSchema::enumValues(const schemaPath_& location, const ModuleNodePair& node) const |
| 123 | { |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 124 | if (!isLeaf(location, node) || leafType(location, node) != yang::LeafDataTypes::Enum) |
Václav Kubernát | 989b5de | 2019-02-20 16:28:35 +0100 | [diff] [blame] | 125 | return {}; |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 126 | |
Jan Kundrát | 4ed0e9f | 2018-08-23 16:56:58 +0200 | [diff] [blame] | 127 | libyang::Schema_Node_Leaf leaf(getSchemaNode(location, node)); |
Václav Kubernát | 6a713d6 | 2018-10-03 18:47:34 +0200 | [diff] [blame] | 128 | auto type = leaf.type(); |
| 129 | auto enm = type->info()->enums()->enm(); |
| 130 | // The enum can be a derived type and enm() only returns values, |
| 131 | // if that specific typedef changed the possible values. So we go |
| 132 | // up the hierarchy until we find a typedef that defined these values. |
| 133 | while (enm.empty()) { |
| 134 | type = type->der()->type(); |
| 135 | enm = type->info()->enums()->enm(); |
| 136 | } |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 137 | |
Václav Kubernát | 989b5de | 2019-02-20 16:28:35 +0100 | [diff] [blame] | 138 | std::set<std::string> enumSet; |
| 139 | std::transform(enm.begin(), enm.end(), std::inserter(enumSet, enumSet.end()), [](auto it) { return it->name(); }); |
| 140 | return enumSet; |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 141 | } |
| 142 | |
Václav Kubernát | eeb3884 | 2019-03-20 19:46:05 +0100 | [diff] [blame] | 143 | const std::set<std::string> YangSchema::validIdentities(const schemaPath_& location, const ModuleNodePair& node, const Prefixes prefixes) const |
| 144 | { |
| 145 | if (!isLeaf(location, node) || leafType(location, node) != yang::LeafDataTypes::IdentityRef) |
| 146 | return {}; |
| 147 | |
| 148 | std::set<std::string> identSet; |
| 149 | |
| 150 | auto topLevelModule = location.m_nodes.empty() ? node.first.get() : location.m_nodes.front().m_prefix.get().m_name; |
| 151 | auto insertToSet = [&identSet, prefixes, topLevelModule](auto module, auto name) { |
| 152 | std::string stringIdent; |
| 153 | if (prefixes == Prefixes::Always || topLevelModule != module) { |
| 154 | stringIdent += module; |
| 155 | stringIdent += ":"; |
| 156 | } |
| 157 | stringIdent += name; |
| 158 | identSet.emplace(stringIdent); |
| 159 | }; |
| 160 | |
| 161 | auto leaf = std::make_shared<libyang::Schema_Node_Leaf>(getSchemaNode(location, node)); |
| 162 | auto info = leaf->type()->info(); |
| 163 | for (auto base : info->ident()->ref()) { // Iterate over all bases |
| 164 | insertToSet(base->module()->name(), base->name()); |
| 165 | // Iterate over derived identities (this is recursive!) |
| 166 | for (auto derived : base->der()->schema()) { |
| 167 | insertToSet(derived->module()->name(), derived->name()); |
| 168 | } |
| 169 | } |
| 170 | |
| 171 | return identSet; |
| 172 | } |
| 173 | |
| 174 | bool YangSchema::leafIdentityIsValid(const schemaPath_& location, const ModuleNodePair& node, const ModuleValuePair& value) const |
| 175 | { |
| 176 | auto identities = validIdentities(location, node, Prefixes::Always); |
| 177 | |
| 178 | auto topLevelModule = location.m_nodes.empty() ? node.first.get() : location.m_nodes.front().m_prefix.get().m_name; |
| 179 | auto identModule = value.first ? value.first.value() : topLevelModule; |
Václav Kubernát | 1bf704e | 2019-04-12 13:30:50 +0200 | [diff] [blame] | 180 | return std::any_of(identities.begin(), identities.end(), [toFind = identModule + ":" + value.second](const auto& x) { return x == toFind; }); |
Václav Kubernát | eeb3884 | 2019-03-20 19:46:05 +0100 | [diff] [blame] | 181 | } |
| 182 | |
Václav Kubernát | 2eaceb8 | 2018-10-08 19:56:30 +0200 | [diff] [blame] | 183 | bool YangSchema::listHasKey(const schemaPath_& location, const ModuleNodePair& node, const std::string& key) const |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 184 | { |
| 185 | if (!isList(location, node)) |
| 186 | return false; |
| 187 | const auto keys = listKeys(location, node); |
| 188 | return keys.find(key) != keys.end(); |
| 189 | } |
| 190 | |
Václav Kubernát | 280df4a | 2019-11-01 14:46:34 +0100 | [diff] [blame] | 191 | libyang::S_Schema_Node YangSchema::getSchemaNode(const schemaPath_& location, const ModuleNodePair& node) const |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 192 | { |
| 193 | std::string absPath = location.m_nodes.empty() ? "" : "/"; |
| 194 | absPath += pathToAbsoluteSchemaString(location) + "/" + fullNodeName(location, node); |
Václav Kubernát | f2b91e0 | 2019-04-11 15:36:48 +0200 | [diff] [blame] | 195 | |
| 196 | // If no node is found find_path prints an error message, so we have to |
| 197 | // disable logging |
| 198 | // https://github.com/CESNET/libyang/issues/753 |
| 199 | { |
| 200 | int oldOptions; |
| 201 | auto logBlocker = make_unique_resource( |
| 202 | [&oldOptions]() { |
| 203 | oldOptions = libyang::set_log_options(0); |
| 204 | }, |
| 205 | [&oldOptions]() { |
| 206 | libyang::set_log_options(oldOptions); |
| 207 | }); |
Václav Kubernát | 280df4a | 2019-11-01 14:46:34 +0100 | [diff] [blame] | 208 | return m_context->get_node(nullptr, absPath.c_str()); |
Václav Kubernát | f2b91e0 | 2019-04-11 15:36:48 +0200 | [diff] [blame] | 209 | } |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 210 | } |
| 211 | |
Václav Kubernát | 2eaceb8 | 2018-10-08 19:56:30 +0200 | [diff] [blame] | 212 | const std::set<std::string> YangSchema::listKeys(const schemaPath_& location, const ModuleNodePair& node) const |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 213 | { |
| 214 | std::set<std::string> keys; |
| 215 | if (!isList(location, node)) |
| 216 | return keys; |
Jan Kundrát | 4ed0e9f | 2018-08-23 16:56:58 +0200 | [diff] [blame] | 217 | libyang::Schema_Node_List list(getSchemaNode(location, node)); |
Jan Kundrát | 4030b77 | 2018-08-23 15:54:56 +0200 | [diff] [blame] | 218 | const auto& keysVec = list.keys(); |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 219 | |
Jan Kundrát | 4030b77 | 2018-08-23 15:54:56 +0200 | [diff] [blame] | 220 | std::transform(keysVec.begin(), keysVec.end(), std::inserter(keys, keys.begin()), |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 221 | [] (const auto& it) {return it->name();}); |
| 222 | return keys; |
| 223 | } |
| 224 | |
Václav Kubernát | 6a8d1d9 | 2019-04-24 20:30:36 +0200 | [diff] [blame] | 225 | yang::LeafDataTypes lyTypeToLeafDataTypes(LY_DATA_TYPE type) |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 226 | { |
Václav Kubernát | 6a8d1d9 | 2019-04-24 20:30:36 +0200 | [diff] [blame] | 227 | switch (type) { |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 228 | case LY_TYPE_STRING: |
| 229 | return yang::LeafDataTypes::String; |
| 230 | case LY_TYPE_DEC64: |
| 231 | return yang::LeafDataTypes::Decimal; |
| 232 | case LY_TYPE_BOOL: |
| 233 | return yang::LeafDataTypes::Bool; |
Ivona Oboňová | 88c78ca | 2019-07-02 18:40:07 +0200 | [diff] [blame] | 234 | case LY_TYPE_INT8: |
| 235 | return yang::LeafDataTypes::Int8; |
| 236 | case LY_TYPE_INT16: |
| 237 | return yang::LeafDataTypes::Int16; |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 238 | case LY_TYPE_INT32: |
Ivona Oboňová | 88c78ca | 2019-07-02 18:40:07 +0200 | [diff] [blame] | 239 | return yang::LeafDataTypes::Int32; |
| 240 | case LY_TYPE_INT64: |
| 241 | return yang::LeafDataTypes::Int64; |
| 242 | case LY_TYPE_UINT8: |
| 243 | return yang::LeafDataTypes::Uint8; |
| 244 | case LY_TYPE_UINT16: |
| 245 | return yang::LeafDataTypes::Uint16; |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 246 | case LY_TYPE_UINT32: |
Ivona Oboňová | 88c78ca | 2019-07-02 18:40:07 +0200 | [diff] [blame] | 247 | return yang::LeafDataTypes::Uint32; |
| 248 | case LY_TYPE_UINT64: |
| 249 | return yang::LeafDataTypes::Uint64; |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 250 | case LY_TYPE_ENUM: |
| 251 | return yang::LeafDataTypes::Enum; |
Václav Kubernát | ab53899 | 2019-03-06 15:30:50 +0100 | [diff] [blame] | 252 | case LY_TYPE_BINARY: |
| 253 | return yang::LeafDataTypes::Binary; |
Václav Kubernát | eeb3884 | 2019-03-20 19:46:05 +0100 | [diff] [blame] | 254 | case LY_TYPE_IDENT: |
| 255 | return yang::LeafDataTypes::IdentityRef; |
Václav Kubernát | 6a8d1d9 | 2019-04-24 20:30:36 +0200 | [diff] [blame] | 256 | case LY_TYPE_LEAFREF: |
| 257 | return yang::LeafDataTypes::LeafRef; |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 258 | default: |
Václav Kubernát | 6a8d1d9 | 2019-04-24 20:30:36 +0200 | [diff] [blame] | 259 | using namespace std::string_literals; |
| 260 | throw std::logic_error{"internal error: unsupported libyang data type "s + std::to_string(type)}; |
| 261 | } |
| 262 | |
| 263 | } |
| 264 | |
| 265 | yang::LeafDataTypes YangSchema::leafType(const schemaPath_& location, const ModuleNodePair& node) const |
| 266 | { |
| 267 | using namespace std::string_literals; |
| 268 | if (!isLeaf(location, node)) |
| 269 | throw InvalidSchemaQueryException(fullNodeName(location, node) + " is not a leaf"); |
| 270 | |
| 271 | libyang::Schema_Node_Leaf leaf(getSchemaNode(location, node)); |
| 272 | auto baseType{leaf.type()->base()}; |
| 273 | try { |
| 274 | return lyTypeToLeafDataTypes(baseType); |
| 275 | } catch(std::logic_error& ex) { |
| 276 | throw UnsupportedYangTypeException("the type of "s + fullNodeName(location, node) + " is not supported: " + ex.what()); |
| 277 | } |
| 278 | } |
| 279 | |
| 280 | yang::LeafDataTypes YangSchema::leafrefBase(const schemaPath_& location, const ModuleNodePair & node) const |
| 281 | { |
| 282 | using namespace std::string_literals; |
| 283 | libyang::Schema_Node_Leaf leaf(getSchemaNode(location, node)); |
| 284 | try { |
| 285 | return lyTypeToLeafDataTypes(leaf.type()->info()->lref()->target()->type()->base()); |
| 286 | } catch(std::logic_error& ex) { |
| 287 | throw UnsupportedYangTypeException("the type of "s + fullNodeName(location, node) + " is not supported: " + ex.what()); |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 288 | } |
| 289 | } |
| 290 | |
| 291 | std::set<std::string> YangSchema::modules() const |
| 292 | { |
Jan Kundrát | 4030b77 | 2018-08-23 15:54:56 +0200 | [diff] [blame] | 293 | const auto& modules = m_context->get_module_iter(); |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 294 | |
| 295 | std::set<std::string> res; |
Jan Kundrát | 4030b77 | 2018-08-23 15:54:56 +0200 | [diff] [blame] | 296 | std::transform(modules.begin(), modules.end(), |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 297 | std::inserter(res, res.end()), |
| 298 | [] (const auto module) { return module->name(); }); |
| 299 | return res; |
| 300 | } |
| 301 | |
Václav Kubernát | 2eaceb8 | 2018-10-08 19:56:30 +0200 | [diff] [blame] | 302 | std::set<std::string> YangSchema::childNodes(const schemaPath_& path, const Recursion recursion) const |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 303 | { |
| 304 | using namespace std::string_view_literals; |
| 305 | std::set<std::string> res; |
Václav Kubernát | e7d4aea | 2018-09-11 18:15:48 +0200 | [diff] [blame] | 306 | std::vector<libyang::S_Schema_Node> nodes; |
| 307 | |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 308 | if (path.m_nodes.empty()) { |
Václav Kubernát | e7d4aea | 2018-09-11 18:15:48 +0200 | [diff] [blame] | 309 | nodes = m_context->data_instantiables(0); |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 310 | } else { |
| 311 | const auto absolutePath = "/" + pathToAbsoluteSchemaString(path); |
| 312 | const auto set = m_context->find_path(absolutePath.c_str()); |
Václav Kubernát | e7d4aea | 2018-09-11 18:15:48 +0200 | [diff] [blame] | 313 | const auto schemaSet = set->schema(); |
Václav Kubernát | 7d82da7 | 2019-04-11 15:16:38 +0200 | [diff] [blame] | 314 | nodes = (*schemaSet.begin())->child_instantiables(0); |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 315 | } |
Václav Kubernát | e7d4aea | 2018-09-11 18:15:48 +0200 | [diff] [blame] | 316 | |
| 317 | for (const auto node : nodes) { |
| 318 | if (node->module()->name() == "ietf-yang-library"sv) |
Václav Kubernát | 89728d8 | 2018-09-13 16:28:28 +0200 | [diff] [blame] | 319 | continue; |
Václav Kubernát | e7d4aea | 2018-09-11 18:15:48 +0200 | [diff] [blame] | 320 | if (recursion == Recursion::Recursive) { |
| 321 | for (auto it : node->tree_dfs()) { |
| 322 | res.insert(it->path(LYS_PATH_FIRST_PREFIX)); |
| 323 | } |
| 324 | } else { |
Václav Kubernát | 4f77a25 | 2019-02-19 16:51:30 +0100 | [diff] [blame] | 325 | std::string toInsert; |
| 326 | if (path.m_nodes.empty() || path.m_nodes.front().m_prefix.get().m_name != node->module()->name()) { |
| 327 | toInsert += node->module()->name(); |
| 328 | toInsert += ":"; |
| 329 | } |
| 330 | toInsert += node->name(); |
| 331 | res.insert(toInsert); |
Václav Kubernát | e7d4aea | 2018-09-11 18:15:48 +0200 | [diff] [blame] | 332 | } |
| 333 | } |
| 334 | |
Václav Kubernát | 0d4db44 | 2018-07-18 17:18:43 +0200 | [diff] [blame] | 335 | return res; |
| 336 | } |
Václav Kubernát | a6c5fff | 2018-09-07 15:16:25 +0200 | [diff] [blame] | 337 | |
Václav Kubernát | 9456b5c | 2019-10-02 21:14:52 +0200 | [diff] [blame] | 338 | std::set<std::string> YangSchema::moduleNodes(const module_& module, const Recursion recursion) const |
| 339 | { |
| 340 | std::set<std::string> res; |
| 341 | const auto yangModule = m_context->get_module(module.m_name.c_str()); |
| 342 | |
| 343 | std::vector<libyang::S_Schema_Node> nodes; |
| 344 | |
| 345 | for (const auto node : yangModule->data_instantiables(0)) { |
| 346 | if (recursion == Recursion::Recursive) { |
| 347 | for (const auto it : node->tree_dfs()) { |
| 348 | res.insert(it->path(LYS_PATH_FIRST_PREFIX)); |
| 349 | } |
| 350 | } else { |
| 351 | res.insert(module.m_name + ":" + node->name()); |
| 352 | } |
| 353 | } |
| 354 | |
| 355 | return res; |
| 356 | } |
| 357 | |
Václav Kubernát | a6c5fff | 2018-09-07 15:16:25 +0200 | [diff] [blame] | 358 | void YangSchema::loadModule(const std::string& moduleName) |
| 359 | { |
| 360 | m_context->load_module(moduleName.c_str()); |
| 361 | } |
| 362 | |
| 363 | void YangSchema::registerModuleCallback(const std::function<std::string(const char*, const char*, const char*)>& clb) |
| 364 | { |
| 365 | auto lambda = [clb](const char* mod_name, const char* mod_revision, const char* submod_name, const char* submod_revision) { |
| 366 | (void)submod_revision; |
| 367 | auto moduleSource = clb(mod_name, mod_revision, submod_name); |
| 368 | if (moduleSource.empty()) { |
| 369 | return libyang::Context::mod_missing_cb_return{LYS_IN_YANG, nullptr}; |
| 370 | } |
| 371 | return libyang::Context::mod_missing_cb_return{LYS_IN_YANG, strdup(moduleSource.c_str())}; |
| 372 | }; |
| 373 | |
| 374 | auto deleter = [](void* data) { |
| 375 | free(data); |
| 376 | }; |
| 377 | m_context->add_missing_module_callback(lambda, deleter); |
| 378 | } |
Václav Kubernát | c31bd60 | 2019-03-07 11:44:48 +0100 | [diff] [blame] | 379 | |
| 380 | std::shared_ptr<libyang::Data_Node> YangSchema::dataNodeFromPath(const std::string& path, const std::optional<const std::string> value) const |
| 381 | { |
| 382 | return std::make_shared<libyang::Data_Node>(m_context, |
| 383 | path.c_str(), |
| 384 | value ? value.value().c_str() : nullptr, |
| 385 | LYD_ANYDATA_CONSTSTRING, |
| 386 | 0); |
| 387 | } |
| 388 | |
| 389 | std::shared_ptr<libyang::Module> YangSchema::getYangModule(const std::string& name) |
| 390 | { |
| 391 | return m_context->get_module(name.c_str(), nullptr, 0); |
| 392 | } |