libyang  0.16.105
YANG data modeling language library
Tree_Schema.cpp
Go to the documentation of this file.
1 
15 #include <iostream>
16 #include <memory>
17 #include <stdexcept>
18 #include <vector>
19 
20 #include "Internal.hpp"
21 #include "Libyang.hpp"
22 #include "Tree_Schema.hpp"
23 
24 extern "C" {
25 #include "libyang.h"
26 #include "tree_schema.h"
27 }
28 
29 namespace libyang {
30 
31 Module::Module(struct lys_module *module, S_Deleter deleter):
32  module(module),
33  deleter(deleter)
34 {};
36 S_Revision Module::rev() LY_NEW(module, rev, Revision);
37 std::vector<S_Deviation> Module::deviation() LY_NEW_LIST(module, deviation, deviation_size, Deviation);
38 Submodule::Submodule(struct lys_submodule *submodule, S_Deleter deleter):
39  submodule(submodule),
40  deleter(deleter)
41 {};
42 std::vector<S_Schema_Node> Module::data_instantiables(int options) {
43  std::vector<S_Schema_Node> s_vector;
44  struct lys_node *iter = NULL;
45 
46  while ((iter = (struct lys_node *)lys_getnext(iter, NULL, module, options))) {
47  s_vector.push_back(std::make_shared<Schema_Node>(iter, deleter));
48  }
49 
50  return s_vector;
51 }
52 std::string Module::print_mem(LYS_OUTFORMAT format, int options) {
53  char *strp = nullptr;
54  int rc = 0;
55 
56  rc = lys_print_mem(&strp, module, format, NULL, 0, options);
57  if (rc) {
58  check_libyang_error(module->ctx);
59  return nullptr;
60  }
61 
62  std::string s_strp = strp;
63  free(strp);
64  return s_strp;
65 }
66 std::string Module::print_mem(LYS_OUTFORMAT format, const char *target, int options) {
67  char *strp = nullptr;
68  int rc = 0;
69 
70  rc = lys_print_mem(&strp, module, format, target, 0, options);
71  if (rc) {
72  check_libyang_error(module->ctx);
73  return nullptr;
74  }
75 
76  std::string s_strp = strp;
77  free(strp);
78  return s_strp;
79 }
81 S_Revision Submodule::rev() LY_NEW(submodule, rev, Revision);
82 std::vector<S_Deviation> Submodule::deviation() LY_NEW_LIST(submodule, deviation, deviation_size, Deviation);
83 
84 Type_Info_Binary::Type_Info_Binary(struct lys_type_info_binary *info_binary, S_Deleter deleter):
85  info_binary(info_binary),
86  deleter(deleter)
87 {};
89 S_Restr Type_Info_Binary::length() {return info_binary->length ? std::make_shared<Restr>(info_binary->length, deleter) : nullptr;};
90 
91 Type_Bit::Type_Bit(struct lys_type_bit *info_bit, S_Deleter deleter):
92  info_bit(info_bit),
93  deleter(deleter)
94 {};
96 std::vector<S_Ext_Instance> Type_Bit::ext() LY_NEW_P_LIST(info_bit, ext, ext_size, Ext_Instance);
97 std::vector<S_Iffeature> Type_Bit::iffeature() LY_NEW_LIST(info_bit, iffeature, iffeature_size, Iffeature);
98 
99 Type_Info_Bits::Type_Info_Bits(struct lys_type_info_bits *info_bits, S_Deleter deleter):
100  info_bits(info_bits),
101  deleter(deleter)
102 {};
104 std::vector<S_Type_Bit> Type_Info_Bits::bit() LY_NEW_LIST(info_bits, bit, count, Type_Bit);
105 
106 Type_Info_Dec64::Type_Info_Dec64(struct lys_type_info_dec64 *info_dec64, S_Deleter deleter):
107  info_dec64(info_dec64),
108  deleter(deleter)
109 {};
111 S_Restr Type_Info_Dec64::range() {return info_dec64->range ? std::make_shared<Restr>(info_dec64->range, deleter) : nullptr;};
112 
113 Type_Enum::Type_Enum(struct lys_type_enum *info_enum, S_Deleter deleter):
114  info_enum(info_enum),
115  deleter(deleter)
116 {};
118 std::vector<S_Ext_Instance> Type_Enum::ext() LY_NEW_P_LIST(info_enum, ext, ext_size, Ext_Instance);
119 std::vector<S_Iffeature> Type_Enum::iffeature() LY_NEW_LIST(info_enum, iffeature, iffeature_size, Iffeature);
120 
121 Type_Info_Enums::Type_Info_Enums(struct lys_type_info_enums *info_enums, S_Deleter deleter):
122  info_enums(info_enums),
123  deleter(deleter)
124 {};
126 std::vector<S_Type_Enum> Type_Info_Enums::enm() LY_NEW_LIST(info_enums, enm, count, Type_Enum);
127 
128 Type_Info_Ident::Type_Info_Ident(struct lys_type_info_ident *info_ident, S_Deleter deleter):
129  info_ident(info_ident),
130  deleter(deleter)
131 {};
133 std::vector<S_Ident> Type_Info_Ident::ref() LY_NEW_P_LIST(info_ident, ref, count, Ident);
134 
135 Type_Info_Inst::Type_Info_Inst(struct lys_type_info_inst *info_inst, S_Deleter deleter):
136  info_inst(info_inst),
137  deleter(deleter)
138 {};
140 
141 Type_Info_Num::Type_Info_Num(struct lys_type_info_num *info_num, S_Deleter deleter):
142  info_num(info_num),
143  deleter(deleter)
144 {};
146 S_Restr Type_Info_Num::range() {return info_num->range ? std::make_shared<Restr>(info_num->range, deleter) : nullptr;};
147 
148 Type_Info_Lref::Type_Info_Lref(lys_type_info_lref *info_lref, S_Deleter deleter):
149  info_lref(info_lref),
150  deleter(deleter)
151 {};
153 S_Schema_Node_Leaf Type_Info_Lref::target() {return info_lref->target ? std::make_shared<Schema_Node_Leaf>((struct lys_node *)info_lref->target, deleter) : nullptr;};
154 
155 Type_Info_Str::Type_Info_Str(lys_type_info_str *info_str, S_Deleter deleter):
156  info_str(info_str),
157  deleter(deleter)
158 {};
160 S_Restr Type_Info_Str::length() {return info_str->length ? std::make_shared<Restr>(info_str->length, deleter) : nullptr;};
161 S_Restr Type_Info_Str::patterns() {return info_str->patterns ? std::make_shared<Restr>(info_str->patterns, deleter) : nullptr;};
162 
164  info_union(info_union),
165  deleter(deleter)
166 {};
168 std::vector<S_Type> Type_Info_Union::types() LY_NEW_LIST(info_union, types, count, Type);
169 
170 Type_Info::Type_Info(union lys_type_info info, LY_DATA_TYPE *type, uint8_t flags, S_Deleter deleter):
171  info(info),
172  type(*type),
173  flags(flags),
174  deleter(deleter)
175 {};
177 S_Type_Info_Binary Type_Info::binary() {return LY_TYPE_BINARY == type ? std::make_shared<Type_Info_Binary>(&info.binary, deleter) : nullptr;};
178 S_Type_Info_Bits Type_Info::bits() {return LY_TYPE_BITS == type ? std::make_shared<Type_Info_Bits>(&info.bits, deleter) : nullptr;};
179 S_Type_Info_Dec64 Type_Info::dec64() {return LY_TYPE_DEC64 == type ? std::make_shared<Type_Info_Dec64>(&info.dec64, deleter) : nullptr;};
180 S_Type_Info_Enums Type_Info::enums() {return LY_TYPE_ENUM == type ? std::make_shared<Type_Info_Enums>(&info.enums, deleter) : nullptr;};
181 S_Type_Info_Ident Type_Info::ident() {return LY_TYPE_IDENT == type ? std::make_shared<Type_Info_Ident>(&info.ident, deleter) : nullptr;};
182 S_Type_Info_Inst Type_Info::inst() {return LY_TYPE_INST == type ? std::make_shared<Type_Info_Inst>(&info.inst, deleter) : nullptr;};
183 S_Type_Info_Num Type_Info::num() {
184  if (type >= LY_TYPE_INT8 && type <= LY_TYPE_UINT64) {
185  return std::make_shared<Type_Info_Num>(&info.num, deleter);
186  } else {
187  return nullptr;
188  }
189 };
190 S_Type_Info_Lref Type_Info::lref() {return LY_TYPE_LEAFREF == type ? std::make_shared<Type_Info_Lref>(&info.lref, deleter) : nullptr;};
191 S_Type_Info_Str Type_Info::str() {return LY_TYPE_STRING == type ? std::make_shared<Type_Info_Str>(&info.str, deleter) : nullptr;};
192 S_Type_Info_Union Type_Info::uni() {return LY_TYPE_UNION == type ? std::make_shared<Type_Info_Union>(&info.uni, deleter) : nullptr;};
193 
194 Type::Type(struct lys_type *type, S_Deleter deleter):
195  type(type),
196  deleter(deleter)
197 {};
199 std::vector<S_Ext_Instance> Type::ext() LY_NEW_P_LIST(type, ext, ext_size, Ext_Instance);
200 S_Tpdf Type::der() {return type->der ? std::make_shared<Tpdf>(type->der, deleter) : nullptr;};
201 S_Tpdf Type::parent() {return type->parent ? std::make_shared<Tpdf>(type->parent, deleter) : nullptr;};
202 S_Type_Info Type::info() {return std::make_shared<Type_Info>(type->info, &type->base, type->value_flags, deleter);};
203 
204 Iffeature::Iffeature(struct lys_iffeature *iffeature, S_Deleter deleter):
206  deleter(deleter)
207 {};
209 std::vector<S_Feature> Iffeature::features() {
210  std::vector<S_Feature> s_vector;
211 
212  for (size_t i = 0; i < sizeof(*iffeature->features); i++) {
213  s_vector.push_back(std::make_shared<Feature>(iffeature->features[i], deleter));
214  }
215 
216  return s_vector;
217 };
218 std::vector<S_Ext_Instance> Iffeature::ext() LY_NEW_P_LIST(iffeature, ext, ext_size, Ext_Instance);
219 
220 Ext_Instance::Ext_Instance(lys_ext_instance *ext_instance, S_Deleter deleter):
221  ext_instance(ext_instance),
222  deleter(deleter)
223 {};
225 std::vector<S_Ext_Instance> Ext_Instance::ext() LY_NEW_P_LIST(ext_instance, ext, ext_size, Ext_Instance);
226 
227 Revision::Revision(lys_revision *revision, S_Deleter deleter):
228  revision(revision),
229  deleter(deleter)
230 {};
232 
233 Schema_Node::Schema_Node(struct lys_node *node, S_Deleter deleter):
234  node(node),
235  deleter(deleter)
236 {};
238 std::vector<S_Ext_Instance> Schema_Node::ext() LY_NEW_P_LIST(node, ext, ext_size, Ext_Instance);
239 S_Module Schema_Node::module() LY_NEW(node, module, Module);
240 S_Schema_Node Schema_Node::parent() LY_NEW(node, parent, Schema_Node);
241 S_Schema_Node Schema_Node::child() LY_NEW(node, child, Schema_Node);
242 S_Schema_Node Schema_Node::next() LY_NEW(node, next, Schema_Node);
243 S_Schema_Node Schema_Node::prev() LY_NEW(node, prev, Schema_Node);
244 std::string Schema_Node::path(int options) {
245  char *path = nullptr;
246 
247  path = lys_path(node, options);
248  if (!path) {
249  return nullptr;
250  }
251 
252  std::string s_path = path;
253  free(path);
254  return s_path;
255 }
256 std::vector<S_Schema_Node> Schema_Node::child_instantiables(int options) {
257  std::vector<S_Schema_Node> s_vector;
258  struct lys_node *iter = NULL;
259 
260  while ((iter = (struct lys_node *)lys_getnext(iter, node, node->module, options))) {
261  s_vector.push_back(std::make_shared<Schema_Node>(iter, deleter));
262  }
263 
264  return s_vector;
265 }
266 S_Set Schema_Node::find_path(const char *path) {
267  struct ly_set *set = lys_find_path(node->module, node, path);
268  if (!set) {
269  check_libyang_error(node->module->ctx);
270  return nullptr;
271  }
272 
273  S_Deleter new_deleter = std::make_shared<Deleter>(set, deleter);
274  return std::make_shared<Set>(set, new_deleter);
275 }
276 
277 S_Set Schema_Node::xpath_atomize(enum lyxp_node_type ctx_node_type, const char *expr, int options) {
278  struct ly_set *set = lys_xpath_atomize(node, ctx_node_type, expr, options);
279  if (!set) {
280  check_libyang_error(node->module->ctx);
281  return nullptr;
282  }
283 
284  return std::make_shared<Set>(set, deleter);
285 }
286 S_Set Schema_Node::xpath_atomize(int options) {
287  struct ly_set *set = lys_node_xpath_atomize(node, options);
288  if (!set) {
289  check_libyang_error(node->module->ctx);
290  return nullptr;
291  }
292 
293  return std::make_shared<Set>(set, deleter);
294 }
295 std::vector<S_Schema_Node> Schema_Node::tree_for() {
296  std::vector<S_Schema_Node> s_vector;
297 
298  struct lys_node *elem = nullptr;
299  LY_TREE_FOR(node, elem) {
300  s_vector.push_back(std::make_shared<Schema_Node>(elem, deleter));
301  }
302 
303  return s_vector;
304 }
305 std::vector<S_Schema_Node> Schema_Node::tree_dfs() {
306  std::vector<S_Schema_Node> s_vector;
307 
308  struct lys_node *elem = nullptr, *next = nullptr;
309  LY_TREE_DFS_BEGIN(node, next, elem) {
310  s_vector.push_back(std::make_shared<Schema_Node>(elem, deleter));
311  LY_TREE_DFS_END(node, next, elem)
312  }
313 
314  return s_vector;
315 }
316 
318 S_When Schema_Node_Container::when() LY_NEW_CASTED(lys_node_container, node, when, When);
319 S_Restr Schema_Node_Container::must() {
320  struct lys_node_container *node_container = (struct lys_node_container *)node;
321  return node_container->must ? std::make_shared<Restr>(node_container->must, deleter) : nullptr;
322 };
324  struct lys_node_container *node_container = (struct lys_node_container *)node;
325  return node_container->tpdf ? std::make_shared<Tpdf>(node_container->tpdf, deleter) : nullptr;
326 };
327 
329 S_When Schema_Node_Choice::when() LY_NEW_CASTED(lys_node_choice, node, when, When);
330 S_Schema_Node Schema_Node_Choice::dflt() {
331  struct lys_node_choice *node_choice = (struct lys_node_choice *)node;
332  return node_choice->dflt ? std::make_shared<Schema_Node>(node_choice->dflt, deleter) : nullptr;
333 };
334 
336 S_Set Schema_Node_Leaf::backlinks() LY_NEW_CASTED(lys_node_leaf, node, backlinks, Set);
337 S_When Schema_Node_Leaf::when() LY_NEW_CASTED(lys_node_leaf, node, when, When);
338 S_Type Schema_Node_Leaf::type() {return std::make_shared<Type>(&((struct lys_node_leaf *)node)->type, deleter);}
339 S_Schema_Node_List Schema_Node_Leaf::is_key() {
340  uint8_t pos;
341 
342  auto list = lys_is_key((struct lys_node_leaf *)node, &pos);
343  return list ? std::make_shared<Schema_Node_List>((struct lys_node *) list, deleter) : nullptr;
344 }
345 
347 S_Set Schema_Node_Leaflist::backlinks() LY_NEW_CASTED(lys_node_leaflist, node, backlinks, Set);
348 S_When Schema_Node_Leaflist::when() LY_NEW_CASTED(lys_node_leaflist, node, when, When);
349 std::vector<std::string> Schema_Node_Leaflist::dflt() {
350  struct lys_node_leaflist *node_leaflist = (struct lys_node_leaflist *)node;
351  LY_NEW_STRING_LIST(node_leaflist, dflt, dflt_size);
352 }
353 std::vector<S_Restr> Schema_Node_Leaflist::must() LY_NEW_LIST_CASTED(lys_node_leaflist, node, must, must_size, Restr);
354 S_Type Schema_Node_Leaflist::type() {return std::make_shared<Type>(&((struct lys_node_leaflist *)node)->type, deleter);}
355 
357 S_When Schema_Node_List::when() LY_NEW_CASTED(lys_node_list, node, when, When);
358 std::vector<S_Restr> Schema_Node_List::must() LY_NEW_LIST_CASTED(lys_node_list, node, must, must_size, Restr);
359 std::vector<S_Tpdf> Schema_Node_List::tpdf() LY_NEW_LIST_CASTED(lys_node_list, node, tpdf, tpdf_size, Tpdf);
360 std::vector<S_Schema_Node_Leaf> Schema_Node_List::keys() {
361  auto list = (struct lys_node_list *) node;
362 
363  std::vector<S_Schema_Node_Leaf> s_vector;
364 
365  for (uint8_t i = 0; i < list->keys_size; i++) {
366  s_vector.push_back(std::make_shared<Schema_Node_Leaf>((struct lys_node *) list->keys[i], deleter));
367  }
368 
369  return s_vector;
370 }
371 std::vector<S_Unique> Schema_Node_List::unique() LY_NEW_LIST_CASTED(lys_node_list, node, unique, unique_size, Unique);
372 
374 S_When Schema_Node_Anydata::when() LY_NEW_CASTED(lys_node_anydata, node, when, When);
375 std::vector<S_Restr> Schema_Node_Anydata::must() LY_NEW_LIST_CASTED(lys_node_anydata, node, must, must_size, Restr);
376 
378 S_When Schema_Node_Uses::when() LY_NEW_CASTED(lys_node_uses, node, when, When);
379 std::vector<S_Refine> Schema_Node_Uses::refine() LY_NEW_LIST_CASTED(lys_node_uses, node, refine, refine_size, Refine);
380 std::vector<S_Schema_Node_Augment> Schema_Node_Uses::augment() {
381  auto uses = (struct lys_node_uses *) node;
382 
383  std::vector<S_Schema_Node_Augment> s_vector;
384 
385  for (uint8_t i = 0; i < uses->augment_size; i++) {
386  s_vector.push_back(std::make_shared<Schema_Node_Augment>((struct lys_node *) &uses->augment[i], deleter));
387  }
388 
389  return s_vector;
390 }
391 S_Schema_Node_Grp Schema_Node_Uses::grp() {
392  auto uses = (struct lys_node_uses *) node;
393  return uses->grp ? std::make_shared<Schema_Node_Grp>(node, deleter) : nullptr;
394 };
395 
397 std::vector<S_Tpdf> Schema_Node_Grp::tpdf() LY_NEW_LIST_CASTED(lys_node_grp, node, tpdf, tpdf_size, Tpdf);
398 
400 S_When Schema_Node_Case::when() LY_NEW_CASTED(lys_node_case, node, when, When);
401 
403 std::vector<S_Tpdf> Schema_Node_Inout::tpdf() LY_NEW_LIST_CASTED(lys_node_inout, node, tpdf, tpdf_size, Tpdf);
404 std::vector<S_Restr> Schema_Node_Inout::must() LY_NEW_LIST_CASTED(lys_node_inout, node, must, must_size, Restr);
405 
407 std::vector<S_Tpdf> Schema_Node_Notif::tpdf() LY_NEW_LIST_CASTED(lys_node_notif, node, tpdf, tpdf_size, Tpdf);
408 std::vector<S_Restr> Schema_Node_Notif::must() LY_NEW_LIST_CASTED(lys_node_notif, node, must, must_size, Restr);
409 
411 std::vector<S_Tpdf> Schema_Node_Rpc_Action::tpdf() LY_NEW_LIST_CASTED(lys_node_rpc_action, node, tpdf, tpdf_size, Tpdf);
412 
414 S_When Schema_Node_Augment::when() LY_NEW_CASTED(lys_node_augment, node, when, When);
415 
416 When::When(struct lys_when *when, S_Deleter deleter):
417  when(when),
418  deleter(deleter)
419 {};
421 std::vector<S_Ext_Instance> When::ext() LY_NEW_P_LIST(when, ext, ext_size, Ext_Instance);
422 
423 Substmt::Substmt(struct lyext_substmt *substmt, S_Deleter deleter):
424  substmt(substmt),
425  deleter(deleter)
426 {};
428 
429 Ext::Ext(struct lys_ext *ext, S_Deleter deleter):
430  ext(ext),
431  deleter(deleter)
432 {};
434 std::vector<S_Ext_Instance> Ext::ext_instance() LY_NEW_P_LIST(ext, ext, ext_size, Ext_Instance);
435 S_Module Ext::module() LY_NEW(ext, module, Module);
436 
437 Refine_Mod_List::Refine_Mod_List(struct lys_refine_mod_list *list, S_Deleter deleter):
438  list(list),
439  deleter(deleter)
440 {};
442 
443 Refine_Mod::Refine_Mod(union lys_refine_mod mod, uint16_t target_type, S_Deleter deleter):
444  mod(mod),
445  target_type(target_type),
446  deleter(deleter)
447 {};
449 //TODO check which type's to accept
450 S_Refine_Mod_List Refine_Mod::list() {return target_type != LYS_CONTAINER ? std::make_shared<Refine_Mod_List>(&mod.list, deleter) : nullptr;};
451 
452 Refine::Refine(struct lys_refine *refine, S_Deleter deleter):
453  refine(refine),
454  deleter(deleter)
455 {};
457 std::vector<S_Ext_Instance> Refine::ext() LY_NEW_P_LIST(refine, ext, ext_size, Ext_Instance);
458 S_Module Refine::module() LY_NEW(refine, module, Module);
459 std::vector<S_Restr> Refine::must() LY_NEW_LIST(refine, must, must_size, Restr);
460 S_Refine_Mod Refine::mod() {return std::make_shared<Refine_Mod>(refine->mod, refine->target_type, deleter);};
461 
462 Deviate::Deviate(struct lys_deviate *deviate, S_Deleter deleter):
463  deviate(deviate),
464  deleter(deleter)
465 {};
467 std::vector<S_Ext_Instance> Deviate::ext() LY_NEW_P_LIST(deviate, ext, ext_size, Ext_Instance);
468 S_Restr Deviate::must() {return deviate->must ? std::make_shared<Restr>(deviate->must, deleter) : nullptr;};
469 S_Unique Deviate::unique() {return deviate->unique ? std::make_shared<Unique>(deviate->unique, deleter) : nullptr;};
470 S_Type Deviate::type() {return deviate->type ? std::make_shared<Type>(deviate->type, deleter) : nullptr;}
471 
472 Deviation::Deviation(struct lys_deviation *deviation, S_Deleter deleter):
473  deviation(deviation),
474  deleter(deleter)
475 {};
477 S_Schema_Node Deviation::orig_node() LY_NEW(deviation, orig_node, Schema_Node);
478 std::vector<S_Deviate> Deviation::deviate() LY_NEW_LIST(deviation, deviate, deviate_size, Deviate);
479 std::vector<S_Ext_Instance> Deviation::ext() LY_NEW_P_LIST(deviation, ext, ext_size, Ext_Instance);
480 
481 Import::Import(struct lys_import *import, S_Deleter deleter):
482  import(import),
483  deleter(deleter)
484 {};
486 
487 Include::Include(struct lys_include *include, S_Deleter deleter):
488  include(include),
489  deleter(deleter)
490 {}
492 
493 Tpdf::Tpdf(struct lys_tpdf *tpdf, S_Deleter deleter):
494  tpdf(tpdf),
495  deleter(deleter)
496 {}
498 S_Type Tpdf::type() {return std::make_shared<Type>(&tpdf->type, deleter);}
499 
500 Unique::Unique(struct lys_unique *unique, S_Deleter deleter):
501  unique(unique),
502  deleter(deleter)
503 {};
505 
506 Feature::Feature(struct lys_feature *feature, S_Deleter deleter):
507  feature(feature),
508  deleter(deleter)
509 {};
511 
512 Restr::Restr(struct lys_restr *restr, S_Deleter deleter):
513  restr(restr),
514  deleter(deleter)
515 {};
517 
518 Ident::Ident(struct lys_ident *ident, S_Deleter deleter):
519  ident(ident),
520  deleter(deleter)
521 {};
523 std::vector<S_Ident> Ident::base() LY_NEW_P_LIST(ident, base, base_size, Ident);
524 
525 }
Type_Enum(struct lys_type_enum *info_enum, S_Deleter deleter)
struct lys_module * module
Definition: tree_schema.h:1245
Common structure representing single YANG data statement describing.
Definition: tree_schema.h:1229
Schema leaf node structure.
Definition: tree_schema.h:1365
S_Type_Info_Enums enums()
const struct lys_node * lys_getnext(const struct lys_node *last, const struct lys_node *parent, const struct lys_module *module, int options)
Get next schema tree (sibling) node element that can be instantiated in a data tree. Returned node can be from an augment.
Ident(struct lys_ident *ident, S_Deleter deleter)
Tpdf(struct lys_tpdf *tpdf, S_Deleter deleter)
Schema grouping node structure.
Definition: tree_schema.h:1628
std::vector< S_Type_Enum > enm()
struct lys_type_info_bits bits
Definition: tree_schema.h:967
S_Schema_Node_Leaf target()
struct lys_type_info_inst inst
Definition: tree_schema.h:971
Submodule schema node structure that can be included into a YANG module.
Definition: tree_schema.h:737
Unique(struct lys_unique *unique, S_Deleter deleter)
Schema choice node structure.
Definition: tree_schema.h:1323
std::vector< S_Ext_Instance > ext()
struct lys_type_info_num num
Definition: tree_schema.h:972
struct lys_unique * unique
Definition: tree_schema.h:1512
S_Revision rev()
Definition: Tree_Schema.cpp:36
Module(struct lys_module *module, S_Deleter deleter)
Definition: Tree_Schema.cpp:31
struct lys_node * dflt
Definition: tree_schema.h:1351
std::vector< S_Schema_Node > tree_for()
struct lys_restr * patterns
Definition: tree_schema.h:938
struct lys_refine_mod_list list
Definition: tree_schema.h:1890
std::vector< S_Ext_Instance > ext()
uint8_t iffeature_size
Definition: tree_schema.h:1235
Type_Bit(struct lys_type_bit *info_bit, S_Deleter deleter)
Definition: Tree_Schema.cpp:91
S_Revision rev()
Definition: Tree_Schema.cpp:81
std::vector< S_Tpdf > tpdf()
YANG uses&#39;s refine substatement structure, see RFC 6020 sec. 7.12.2
Definition: tree_schema.h:1897
std::vector< S_Schema_Node > tree_dfs()
YANG import structure used to reference other schemas (modules).
Definition: tree_schema.h:1981
std::vector< S_Schema_Node > data_instantiables(int options)
Definition: Tree_Schema.cpp:42
S_Type_Info_Inst inst()
Container for list modifications in lys_refine_mod.
Definition: tree_schema.h:1880
Container for information about string types (LY_TYPE_STRING), used in lys_type_info.
Definition: tree_schema.h:935
S_Schema_Node_List is_key()
const char ** dflt
Definition: tree_schema.h:1460
libyang representation of data model trees.
Deviate(struct lys_deviate *deviate, S_Deleter deleter)
classes for wrapping lys_submodule.
S_Type_Info_Lref lref()
std::vector< S_Ext_Instance > ext_instance()
struct ly_set * lys_find_path(const struct lys_module *cur_module, const struct lys_node *cur_node, const char *path)
Search for schema nodes matching the provided path.
YANG typedef structure providing information from the schema.
Definition: tree_schema.h:2017
struct lys_restr * length
Definition: tree_schema.h:821
std::vector< S_Tpdf > tpdf()
lyxp_node_type
Types of context nodes, LYXP_NODE_ROOT_CONFIG used only in when or must conditions.
Definition: tree_schema.h:2311
struct lys_type * type
Definition: tree_schema.h:1955
Single enumeration value specification for lys_type_info_enums.
Definition: tree_schema.h:868
Union for holding type-specific information in lys_type.
Definition: tree_schema.h:965
S_Schema_Node_Grp grp()
S_Type_Info_Union uni()
std::vector< S_Feature > features()
struct lys_node * child
Definition: tree_schema.h:1249
Container for information about leafref types (LY_TYPE_LEAFREF), used in lys_type_info.
Definition: tree_schema.h:922
struct lys_tpdf * tpdf
Definition: tree_schema.h:1310
Compiled if-feature expression structure.
Definition: tree_schema.h:1078
union lys_type_info info
Definition: tree_schema.h:990
Schema leaf-list node structure.
Definition: tree_schema.h:1418
YANG augment structure (covering both possibilities - uses&#39;s substatement as well as (sub)module&#39;s su...
Definition: tree_schema.h:1845
LYS_OUTFORMAT
Schema output formats accepted by libyang printer functions.
Definition: tree_schema.h:204
Type_Info_Num(struct lys_type_info_num *info_num, S_Deleter deleter)
Container for information about enumeration types (LY_TYPE_ENUM), used in lys_type_info.
Definition: tree_schema.h:887
Container for information about integer types, used in lys_type_info.
Definition: tree_schema.h:914
The main libyang public header.
std::vector< S_Tpdf > tpdf()
Restr(struct lys_restr *restr, S_Deleter deleter)
Class implementation for libyang C header tree_schema.h.
S_Type_Info_Dec64 dec64()
Union to hold target modification in lys_refine.
Definition: tree_schema.h:1888
Schema anydata (and anyxml) node structure.
Definition: tree_schema.h:1533
Container for information about decimal64 types (LY_TYPE_DEC64), used in lys_type_info.
Definition: tree_schema.h:855
std::vector< S_Restr > must()
Structure to hold a set of (not necessary somehow connected) lyd_node or lys_node objects...
Definition: libyang.h:1716
const char * ref
Definition: tree_schema.h:1232
std::vector< S_Ext_Instance > ext()
struct lys_type_info_lref lref
Definition: tree_schema.h:973
S_Type_Info_Num num()
Type_Info_Union(struct lys_type_info_union *info_union, S_Deleter deleter)
Ext(struct lys_ext *ext, S_Deleter deleter)
std::vector< S_Ext_Instance > ext()
Deviation(struct lys_deviation *deviation, S_Deleter deleter)
S_Unique unique()
struct lys_iffeature * iffeature
Definition: tree_schema.h:1244
virtual S_Schema_Node next()
Container for information about identity types (LY_TYPE_IDENT), used in lys_type_info.
Definition: tree_schema.h:895
YANG when restriction, see RFC 6020 sec. 7.19.5
Definition: tree_schema.h:2088
#define LY_TREE_DFS_BEGIN(START, NEXT, ELEM)
Macro to iterate via all elements in a tree. This is the opening part to the LY_TREE_DFS_END - they a...
Definition: tree_schema.h:98
Type_Info_Lref(struct lys_type_info_lref *info_lref, S_Deleter deleter)
Container for information about bits types (LY_TYPE_BINARY), used in lys_type_info.
Definition: tree_schema.h:847
S_Type_Info_Binary binary()
Schema case node structure.
Definition: tree_schema.h:1667
#define LY_TREE_DFS_END(START, NEXT, ELEM)
Definition: tree_schema.h:130
Schema list node structure.
Definition: tree_schema.h:1474
std::vector< S_Ext_Instance > ext()
Type(struct lys_type *type, S_Deleter deleter)
std::vector< S_Ident > base()
S_Set find_path(const char *path)
Iffeature(struct lys_iffeature *iffeature, S_Deleter deleter)
Refine_Mod(union lys_refine_mod mod, uint16_t target_type, S_Deleter deleter)
Container for information about instance-identifier types (LY_TYPE_INST), used in lys_type_info...
Definition: tree_schema.h:903
Main schema node structure representing YANG module.
Definition: tree_schema.h:674
#define LY_TREE_FOR(START, ELEM)
Macro to iterate via all sibling elements without affecting the list itself.
Definition: tree_schema.h:48
std::vector< S_Type > types()
S_Refine_Mod_List list()
int lys_print_mem(char **strp, const struct lys_module *module, LYS_OUTFORMAT format, const char *target_node, int line_length, int options)
Print schema tree in the specified format into a memory block. It is up to caller to free the returne...
S_Set xpath_atomize(enum lyxp_node_type ctx_node_type, const char *expr, int options)
std::vector< S_Ident > ref()
S_Type_Info_Ident ident()
uint8_t unique_size
Definition: tree_schema.h:1486
Class implementation for libyang C header libyang.h.
Refine(struct lys_refine *refine, S_Deleter deleter)
RPC input and output node structure.
Definition: tree_schema.h:1712
LY_DATA_TYPE _PACKED base
Definition: tree_schema.h:982
LY_DATA_TYPE
YANG built-in types.
Definition: tree_schema.h:792
S_Schema_Node orig_node()
uint8_t ext_size
Definition: tree_schema.h:1234
struct lys_node * next
Definition: tree_schema.h:1253
struct lys_node_leaf * target
Definition: tree_schema.h:925
struct lys_type_info_dec64 dec64
Definition: tree_schema.h:968
struct lys_type_info_binary binary
Definition: tree_schema.h:966
struct lys_type type
Definition: tree_schema.h:1455
struct ly_set * lys_node_xpath_atomize(const struct lys_node *node, int options)
Call lys_xpath_atomize() on all the when and must expressions of the node. This node must be a descen...
std::string print_mem(LYS_OUTFORMAT format, int options)
Definition: Tree_Schema.cpp:52
uint16_t flags
Definition: tree_schema.h:1233
YANG type structure providing information from the schema.
Definition: tree_schema.h:981
char * lys_path(const struct lys_node *node, int options)
Build schema path (usable as path, see XPath Addressing) of the schema node.
std::vector< S_Ext_Instance > ext()
S_Tpdf parent()
struct lys_when * when
Definition: tree_schema.h:1308
YANG list&#39;s unique statement structure, see RFC 6020 sec. 7.8.3
Definition: tree_schema.h:2042
S_Type_Info_Bits bits()
struct lys_refine * refine
Definition: tree_schema.h:1612
Structure to hold information about identity, see RFC 6020 sec. 7.16
Definition: tree_schema.h:2102
struct lys_node * prev
Definition: tree_schema.h:1254
Schema_Node(lys_node *node, S_Deleter deleter)
std::vector< S_Schema_Node > child_instantiables(int options)
Description of the extension instance substatement.
Definition: tree_schema.h:443
S_Type_Info_Str str()
YANG deviate statement structure, see RFC 6020 sec. 7.18.3.2
Definition: tree_schema.h:1938
struct lys_restr * range
Definition: tree_schema.h:856
std::vector< S_Ext_Instance > ext()
Definition: Tree_Schema.cpp:96
struct lys_type_info_enums enums
Definition: tree_schema.h:969
Schema uses node structure.
Definition: tree_schema.h:1581
struct lys_type_info_union uni
Definition: tree_schema.h:975
Schema notification node structure.
Definition: tree_schema.h:1750
std::vector< S_Ext_Instance > ext()
union lys_refine_mod mod
Definition: tree_schema.h:1921
std::vector< S_Unique > unique()
YANG validity restriction (must, length, etc.) structure providing information from the schema...
Definition: tree_schema.h:2072
class for wrapping ly_set.
Definition: Libyang.hpp:186
const struct lys_node_list * lys_is_key(const struct lys_node_leaf *node, uint8_t *index)
Check if the schema leaf node is used as a key for a list.
std::vector< S_Ext_Instance > ext()
Schema rpc/action node structure.
Definition: tree_schema.h:1797
std::string path(int options=0)
struct lys_restr * must
Definition: tree_schema.h:1309
Generic extension instance structure.
Definition: tree_schema.h:472
Container for information about union types (LY_TYPE_UNION), used in lys_type_info.
Definition: tree_schema.h:955
struct lys_tpdf * parent
Definition: tree_schema.h:988
YANG extension definition.
Definition: tree_schema.h:452
struct ly_ctx * ctx
Definition: tree_schema.h:675
uint8_t value_flags
Definition: tree_schema.h:983
YANG revision statement for (sub)modules.
Definition: tree_schema.h:2006
struct lys_type_info_str str
Definition: tree_schema.h:974
YANG include structure used to reference submodules.
Definition: tree_schema.h:1994
YANG feature definition structure.
Definition: tree_schema.h:2051
Feature(struct lys_feature *feature, S_Deleter)
struct lys_feature ** features
Definition: tree_schema.h:1081
Type_Info_Str(struct lys_type_info_str *info_str, S_Deleter deleter)
std::vector< S_Tpdf > tpdf()
Include(struct lys_include *include, S_Deleter deleter)
std::vector< S_Type_Bit > bit()
Single bit value specification for lys_type_info_bits.
Definition: tree_schema.h:828
uint16_t target_type
Definition: tree_schema.h:1906
classes for wrapping lys_module.
Definition: Tree_Schema.hpp:44
S_Type_Info info()
struct lys_type_info_ident ident
Definition: tree_schema.h:970
struct lys_ext_instance ** ext
Definition: tree_schema.h:1243
Schema container node structure.
Definition: tree_schema.h:1275
struct lys_node * parent
Definition: tree_schema.h:1248
YANG deviation statement structure, see RFC 6020 sec. 7.18.3
Definition: tree_schema.h:1965
struct ly_set * lys_xpath_atomize(const struct lys_node *ctx_node, enum lyxp_node_type ctx_node_type, const char *expr, int options)
Get all the partial XPath nodes (atoms) that are required for expr to be evaluated.