libyang  0.16.105
YANG data modeling language library
Tree_Schema.hpp
Go to the documentation of this file.
1 
15 #ifndef TREE_SCHEMA_H
16 #define TREE_SCHEMA_H
17 
18 #include <iostream>
19 #include <memory>
20 #include <exception>
21 #include <vector>
22 
23 #include "Internal.hpp"
24 #include "Libyang.hpp"
25 
26 extern "C" {
27 #include "libyang.h"
28 #include "tree_schema.h"
29 }
30 
31 namespace libyang {
32 
44 class Module
45 {
46 public:
48  Module(struct lys_module *module, S_Deleter deleter);
49  ~Module();
51  const char *name() {return module->name;};
53  const char *prefix() {return module->prefix;};
55  const char *dsc() {return module->dsc;};
57  const char *ref() {return module->ref;};
59  const char *org() {return module->org;};
61  const char *contact() {return module->contact;};
63  const char *filepath() {return module->filepath;};
65  uint8_t type() {return module->type;};
67  uint8_t version() {return module->version;};
69  uint8_t deviated() {return module->deviated;};
71  uint8_t disabled() {return module->disabled;};
73  uint8_t rev_size() {return module->rev_size;};
75  uint8_t imp_size() {return module->imp_size;};
77  uint8_t inc_size() {return module->inc_size;};
79  uint8_t ident_size() {return module->ident_size;};
81  uint8_t tpdf_size() {return module->tpdf_size;};
83  uint8_t features_size() {return module->features_size;};
85  uint8_t augment_size() {return module->augment_size;};
87  uint8_t devaiation_size() {return module->deviation_size;};
89  uint8_t extensions_size() {return module->extensions_size;};
91  uint8_t ext_size() {return module->ext_size;};
93  const char *ns() {return module->ns;};
95  S_Revision rev();
97  std::vector<S_Deviation> deviation();
99  S_Schema_Node data() LY_NEW(module, data, Schema_Node);
101  std::vector<S_Schema_Node> data_instantiables(int options);
103  std::string print_mem(LYS_OUTFORMAT format, int options);
104  std::string print_mem(LYS_OUTFORMAT format, const char *target, int options);
105 
106  friend Context;
107  friend Data_Node;
108 
109 private:
110  struct lys_module *module;
111  S_Deleter deleter;
112 };
113 
119 {
120 public:
122  Submodule(struct lys_submodule *submodule, S_Deleter deleter);
123  ~Submodule();
125  S_Context ctx() LY_NEW(submodule, ctx, Context);
127  const char *name() {return submodule->name;};
129  const char *prefix() {return submodule->prefix;};
131  const char *dsc() {return submodule->dsc;};
133  const char *ref() {return submodule->ref;};
135  const char *org() {return submodule->org;};
137  const char *contact() {return submodule->contact;};
139  const char *filepath() {return submodule->filepath;};
141  uint8_t type() {return submodule->type;};
143  uint8_t version() {return submodule->version;};
145  uint8_t deviated() {return submodule->deviated;};
147  uint8_t disabled() {return submodule->disabled;};
149  uint8_t implemented() {return submodule->implemented;};
151  uint8_t rev_size() {return submodule->rev_size;};
153  uint8_t imp_size() {return submodule->imp_size;};
155  uint8_t inc_size() {return submodule->inc_size;};
157  uint8_t ident_size() {return submodule->ident_size;};
159  uint8_t tpdf_size() {return submodule->tpdf_size;};
161  uint8_t features_size() {return submodule->features_size;};
163  uint8_t augment_size() {return submodule->augment_size;};
165  uint8_t deviation_size() {return submodule->deviation_size;};
167  uint8_t extensions_size() {return submodule->extensions_size;};
169  uint8_t ext_size() {return submodule->ext_size;};
171  S_Revision rev();
173  std::vector<S_Deviation> deviation();
175  S_Module belongsto() LY_NEW(submodule, belongsto, Module);
176 
177 private:
178  struct lys_submodule *submodule;
179  S_Deleter deleter;
180 };
181 
183 {
184 public:
186  Type_Info_Binary(struct lys_type_info_binary *info_binary, S_Deleter deleter);
187  ~Type_Info_Binary();
189  S_Restr length();
190 
191 private:
192  lys_type_info_binary *info_binary;
193  S_Deleter deleter;
194 };
195 
196 class Type_Bit
197 {
198 public:
200  Type_Bit(struct lys_type_bit *info_bit, S_Deleter deleter);
201  ~Type_Bit();
203  const char *name() {return info_bit->name;};
205  const char *dsc() {return info_bit->dsc;};
207  const char *ref() {return info_bit->ref;};
209  uint16_t flags() {return info_bit->flags;};
211  uint8_t ext_size() {return info_bit->ext_size;};
213  uint8_t iffeature_size() {return info_bit->iffeature_size;};
215  uint32_t pos() {return info_bit->pos;};
217  std::vector<S_Ext_Instance> ext();
219  std::vector<S_Iffeature> iffeature();
220 
221 private:
222  lys_type_bit *info_bit;
223  S_Deleter deleter;
224 };
225 
227 {
228 public:
230  Type_Info_Bits(struct lys_type_info_bits *info_bits, S_Deleter deleter);
231  ~Type_Info_Bits();
233  std::vector<S_Type_Bit> bit();
235  unsigned int count() {return info_bits->count;};
236 
237 private:
238  lys_type_info_bits *info_bits;
239  S_Deleter deleter;
240 };
241 
243 {
244 public:
246  Type_Info_Dec64(struct lys_type_info_dec64 *info_dec64, S_Deleter deleter);
247  ~Type_Info_Dec64();
249  S_Restr range();
251  uint8_t dig() {return info_dec64->dig;}
253  uint8_t div() {return info_dec64->div;}
254 
255 private:
256  lys_type_info_dec64 *info_dec64;
257  S_Deleter deleter;
258 };
259 
261 {
262 public:
264  Type_Enum(struct lys_type_enum *info_enum, S_Deleter deleter);
265  ~Type_Enum();
267  const char *name() {return info_enum->name;};
269  const char *dsc() {return info_enum->dsc;};
271  const char *ref() {return info_enum->ref;};
273  uint16_t flags() {return info_enum->flags;};
275  uint8_t ext_size() {return info_enum->ext_size;};
277  uint8_t iffeature_size() {return info_enum->iffeature_size;};
279  int32_t value() {return info_enum->value;};
281  std::vector<S_Ext_Instance> ext();
283  std::vector<S_Iffeature> iffeature();
284 
285 private:
286  lys_type_enum *info_enum;
287  S_Deleter deleter;
288 };
289 
291 {
292 public:
294  Type_Info_Enums(struct lys_type_info_enums *info_enums, S_Deleter deleter);
295  ~Type_Info_Enums();
297  std::vector<S_Type_Enum> enm();
299  unsigned int count() {return info_enums->count;};
300 
301 private:
302  lys_type_info_enums *info_enums;
303  S_Deleter deleter;
304 };
305 
307 {
308 public:
310  Type_Info_Ident(struct lys_type_info_ident *info_ident, S_Deleter deleter);
311  ~Type_Info_Ident();
313  std::vector<S_Ident> ref();
315  int count() {return info_ident->count;};
316 
317 private:
318  lys_type_info_ident *info_ident;
319  S_Deleter deleter;
320 };
321 
323 {
324 public:
326  Type_Info_Inst(struct lys_type_info_inst *info_inst, S_Deleter deleter);
327  ~Type_Info_Inst();
329  int8_t req() {return info_inst->req;};
330 
331 private:
332  lys_type_info_inst *info_inst;
333  S_Deleter deleter;
334 };
335 
337 {
338 public:
340  Type_Info_Num(struct lys_type_info_num *info_num, S_Deleter deleter);
341  ~Type_Info_Num();
343  S_Restr range();
344 
345 private:
346  lys_type_info_num *info_num;
347  S_Deleter deleter;
348 };
349 
351 {
352 public:
354  Type_Info_Lref(struct lys_type_info_lref *info_lref, S_Deleter deleter);
355  ~Type_Info_Lref();
357  const char *path() {return info_lref->path;};
359  S_Schema_Node_Leaf target();
361  int8_t req() {return info_lref->req;};
362 
363 private:
364  lys_type_info_lref *info_lref;
365  S_Deleter deleter;
366 };
367 
369 {
370 public:
372  Type_Info_Str(struct lys_type_info_str *info_str, S_Deleter deleter);
373  ~Type_Info_Str();
375  S_Restr length();
377  S_Restr patterns();
379  int pat_count() {return info_str->pat_count;};
380 
381 private:
382  lys_type_info_str *info_str;
383  S_Deleter deleter;
384 };
385 
387 {
388 public:
390  Type_Info_Union(struct lys_type_info_union *info_union, S_Deleter deleter);
391  ~Type_Info_Union();
393  std::vector<S_Type> types();
395  int count() {return info_union->count;};
397  int has_ptr_type() {return info_union->has_ptr_type;};
398 
399 private:
400  lys_type_info_union *info_union;
401  S_Deleter deleter;
402 };
403 
405 {
406 public:
408  Type_Info(union lys_type_info info, LY_DATA_TYPE *type, uint8_t flags, S_Deleter deleter);
409  ~Type_Info();
411  S_Type_Info_Binary binary();
413  S_Type_Info_Bits bits();
415  S_Type_Info_Dec64 dec64();
417  S_Type_Info_Enums enums();
419  S_Type_Info_Ident ident();
421  S_Type_Info_Inst inst();
423  S_Type_Info_Num num();
425  S_Type_Info_Lref lref();
427  S_Type_Info_Str str();
429  S_Type_Info_Union uni();
430 
431 private:
432  union lys_type_info info;
434  uint8_t flags;
435  S_Deleter deleter;
436 };
437 
438 class Type
439 {
440 public:
442  Type(struct lys_type *type, S_Deleter deleter);
443  ~Type();
445  LY_DATA_TYPE base() {return type->base;};
447  uint8_t ext_size() {return type->ext_size;};
449  std::vector<S_Ext_Instance> ext();
451  S_Tpdf der();
453  S_Tpdf parent();
455  S_Type_Info info();
456 
457 private:
458  struct lys_type *type;
459  S_Deleter deleter;
460 };
461 
462 class Iffeature {
463 public:
465  Iffeature(struct lys_iffeature *iffeature, S_Deleter deleter);
466  ~Iffeature();
468  uint8_t *expr() {return iffeature->expr;};
470  uint8_t ext_size() {return iffeature->ext_size;};
472  std::vector<S_Feature> features();
474  std::vector<S_Ext_Instance> ext();
475 
476 private:
477  struct lys_iffeature *iffeature;
478  S_Deleter deleter;
479 };
480 
482 {
483 public:
485  Ext_Instance(lys_ext_instance *ext_instance, S_Deleter deleter);
486  ~Ext_Instance();
487  //TODO void *parent();
489  const char *arg_value() {return ext_instance->arg_value;};
491  uint16_t flags() {return ext_instance->flags;};
493  uint8_t ext_size() {return ext_instance->ext_size;};
495  uint8_t insubstmt_index() {return ext_instance->insubstmt_index;};
497  uint8_t insubstmt() {return ext_instance->insubstmt;};
499  uint8_t parent_type() {return ext_instance->parent_type;};
501  uint8_t ext_type() {return ext_instance->ext_type;};
503  std::vector<S_Ext_Instance> ext();
505  S_Ext def() LY_NEW(ext_instance, def, Ext);
507  void *priv() {return ext_instance->priv;};
509  S_Module module() LY_NEW(ext_instance, module, Module);
511  LYS_NODE nodetype() {return ext_instance->nodetype;};
512 private:
513  struct lys_ext_instance *ext_instance;
514  S_Deleter deleter;
515 };
516 
518 {
519 public:
521  Schema_Node(lys_node *node, S_Deleter deleter);
522  virtual ~Schema_Node();
524  const char *name() {return node->name;};
526  const char *dsc() {return node->dsc;};
528  const char *ref() {return node->ref;};
530  uint16_t flags() {return node->flags;};
532  uint8_t ext_size() {return node->ext_size;};
534  uint8_t iffeature_size() {return node->iffeature_size;};
536  std::vector<S_Ext_Instance> ext();
538  std::vector<S_Iffeature> iffeature() LY_NEW_LIST(node, iffeature, iffeature_size, Iffeature);
540  S_Module module();
542  LYS_NODE nodetype() {return node->nodetype;};
544  virtual S_Schema_Node parent();
546  virtual S_Schema_Node child();
548  virtual S_Schema_Node next();
550  virtual S_Schema_Node prev();
551 
553  std::string path(int options = 0);
555  int validate_value(const char *value) {return lyd_validate_value(node, value);};
557  std::vector<S_Schema_Node> child_instantiables(int options);
559  S_Set find_path(const char *path);
561  S_Set xpath_atomize(enum lyxp_node_type ctx_node_type, const char *expr, int options);
563  S_Set xpath_atomize(int options);
564  // void *priv;
565 
566  /* emulate TREE macro's */
568  std::vector<S_Schema_Node> tree_for();
570  std::vector<S_Schema_Node> tree_dfs();
571 
572  /* SWIG can not access private variables so it needs public getters */
573  struct lys_node *swig_node() {return node;};
574  S_Deleter swig_deleter() {return deleter;};
575 
576  friend Set;
577  friend Data_Node;
578  friend Context;
593 
594 private:
595  struct lys_node *node;
596  S_Deleter deleter;
597 };
598 
600 {
601 public:
602  Schema_Node_Container(S_Schema_Node derived):
603  Schema_Node(derived->node, derived->deleter),
604  node(derived->node),
605  deleter(derived->deleter)
606  {
607  if (derived->node->nodetype != LYS_CONTAINER) {
608  throw std::invalid_argument("Type must be LYS_CONTAINER");
609  }
610  };
612  Schema_Node_Container(struct lys_node *node, S_Deleter deleter):
613  Schema_Node(node, deleter),
614  node(node),
615  deleter(deleter)
616  {};
619  S_When when();
621  S_Restr must();
623  S_Tpdf ptdf();
625  const char *presence() {return ((struct lys_node_container *) node)->presence;};
626 
627 private:
628  struct lys_node *node;
629  S_Deleter deleter;
630 };
631 
633 {
634 public:
635  Schema_Node_Choice(S_Schema_Node derived):
636  Schema_Node(derived->node, derived->deleter),
637  node(derived->node),
638  deleter(derived->deleter)
639  {
640  if (derived->node->nodetype != LYS_CHOICE) {
641  throw std::invalid_argument("Type must be LYS_CHOICE");
642  }
643  };
645  Schema_Node_Choice(struct lys_node *node, S_Deleter deleter):
646  Schema_Node(node, deleter),
647  node(node),
648  deleter(deleter)
649  {};
652  S_When when();
654  S_Schema_Node dflt();
655 
656 private:
657  struct lys_node *node;
658  S_Deleter deleter;
659 };
660 
662 {
663 public:
664  Schema_Node_Leaf(S_Schema_Node derived):
665  Schema_Node(derived->node, derived->deleter),
666  node(derived->node),
667  deleter(derived->deleter)
668  {
669  if (derived->node->nodetype != LYS_LEAF) {
670  throw std::invalid_argument("Type must be LYS_LEAF");
671  }
672  };
674  Schema_Node_Leaf(struct lys_node *node, S_Deleter deleter):
675  Schema_Node(node, deleter),
676  node(node),
677  deleter(deleter)
678  {};
679  ~Schema_Node_Leaf();
681  S_Set backlinks();
683  S_When when();
685  S_Type type();
687  const char *units() {return ((struct lys_node_leaf *)node)->units;};
689  const char *dflt() {return ((struct lys_node_leaf *)node)->dflt;};
690  S_Schema_Node child() override {return nullptr;};
692  S_Schema_Node_List is_key();
693 
694 private:
695  struct lys_node *node;
696  S_Deleter deleter;
697 };
698 
700 {
701 public:
702  Schema_Node_Leaflist(S_Schema_Node derived):
703  Schema_Node(derived->node, derived->deleter),
704  node(derived->node),
705  deleter(derived->deleter)
706  {
707  if (derived->node->nodetype != LYS_LEAFLIST) {
708  throw std::invalid_argument("Type must be LYS_LEAFLIST");
709  }
710  };
712  Schema_Node_Leaflist(struct lys_node *node, S_Deleter deleter):
713  Schema_Node(node, deleter),
714  node(node),
715  deleter(deleter)
716  {};
719  uint8_t dflt_size() {return ((struct lys_node_leaflist *)node)->dflt_size;};
721  uint8_t must_size() {return ((struct lys_node_leaflist *)node)->must_size;};
723  S_When when();
725  S_Set backlinks();
727  std::vector<S_Restr> must();
729  S_Type type();
731  const char *units() {return ((struct lys_node_leaflist *)node)->units;};
733  std::vector<std::string> dflt();
735  uint32_t min() {return ((struct lys_node_leaflist *)node)->min;};
737  uint32_t max() {return ((struct lys_node_leaflist *)node)->max;};
738  S_Schema_Node child() override {return nullptr;};
739 
740 private:
741  struct lys_node *node;
742  S_Deleter deleter;
743 };
744 
746 {
747 public:
748  Schema_Node_List(S_Schema_Node derived):
749  Schema_Node(derived->node, derived->deleter),
750  node(derived->node),
751  deleter(derived->deleter)
752  {
753  if (derived->node->nodetype != LYS_LIST) {
754  throw std::invalid_argument("Type must be LYS_LIST");
755  }
756  };
758  Schema_Node_List(struct lys_node *node, S_Deleter deleter):
759  Schema_Node(node, deleter),
760  node(node),
761  deleter(deleter)
762  {};
763  ~Schema_Node_List();
765  uint8_t must_size() {return ((struct lys_node_list *)node)->must_size;};
767  uint8_t tpdf_size() {return ((struct lys_node_list *)node)->tpdf_size;};
769  uint8_t keys_size() {return ((struct lys_node_list *)node)->keys_size;};
771  uint8_t unique_size() {return ((struct lys_node_list *)node)->unique_size;};
773  S_When when();
775  std::vector<S_Restr> must();
777  std::vector<S_Tpdf> tpdf();
779  std::vector<S_Schema_Node_Leaf> keys();
781  std::vector<S_Unique> unique();
783  uint32_t min() {return ((struct lys_node_list *)node)->min;};
785  uint32_t max() {return ((struct lys_node_list *)node)->max;};
787  const char *keys_str() {return ((struct lys_node_list *)node)->keys_str;};
788 
789 private:
790  struct lys_node *node;
791  S_Deleter deleter;
792 };
793 
795 {
796 public:
797  Schema_Node_Anydata(S_Schema_Node derived):
798  Schema_Node(derived->node, derived->deleter),
799  node(derived->node),
800  deleter(derived->deleter)
801  {
802  if (derived->node->nodetype != LYS_ANYDATA && derived->node->nodetype != LYS_ANYXML) {
803  throw std::invalid_argument("Type must be LYS_ANYDATA or LYS_ANYXML");
804  }
805  };
807  Schema_Node_Anydata(struct lys_node *node, S_Deleter deleter):
808  Schema_Node(node, deleter),
809  node(node),
810  deleter(deleter)
811  {};
814  uint8_t must_size() {return ((struct lys_node_list *)node)->must_size;};
816  S_When when();
818  std::vector<S_Restr> must();
819 
820 private:
821  struct lys_node *node;
822  S_Deleter deleter;
823 };
824 
826 {
827 public:
828  Schema_Node_Uses(S_Schema_Node derived):
829  Schema_Node(derived->node, derived->deleter),
830  node(derived->node),
831  deleter(derived->deleter)
832  {
833  if (derived->node->nodetype != LYS_USES) {
834  throw std::invalid_argument("Type must be LYS_USES");
835  }
836  };
838  Schema_Node_Uses(struct lys_node *node, S_Deleter deleter):
839  Schema_Node(node, deleter),
840  node(node),
841  deleter(deleter)
842  {};
843  ~Schema_Node_Uses();
845  uint8_t augment_size() {return ((struct lys_node_uses *)node)->augment_size;};
847  S_When when();
849  std::vector<S_Refine> refine();
851  std::vector<S_Schema_Node_Augment> augment();
853  S_Schema_Node_Grp grp();
854 
855 private:
856  struct lys_node *node;
857  S_Deleter deleter;
858 };
859 
861 {
862 public:
863  Schema_Node_Grp(S_Schema_Node derived):
864  Schema_Node(derived->node, derived->deleter),
865  node(derived->node),
866  deleter(derived->deleter)
867  {
868  if (derived->node->nodetype != LYS_GROUPING) {
869  throw std::invalid_argument("Type must be LYS_GROUPING");
870  }
871  };
873  Schema_Node_Grp(struct lys_node *node, S_Deleter deleter):
874  Schema_Node(node, deleter),
875  node(node),
876  deleter(deleter)
877  {};
878  ~Schema_Node_Grp();
880  uint8_t tpdf_size() {return ((struct lys_node_grp *)node)->tpdf_size;};
882  std::vector<S_Tpdf> tpdf();
883 
884 private:
885  struct lys_node *node;
886  S_Deleter deleter;
887 };
888 
890 {
891 public:
892  Schema_Node_Case(S_Schema_Node derived):
893  Schema_Node(derived->node, derived->deleter),
894  node(derived->node),
895  deleter(derived->deleter)
896  {
897  if (derived->node->nodetype != LYS_CASE) {
898  throw std::invalid_argument("Type must be LYS_CASE");
899  }
900  };
902  Schema_Node_Case(struct lys_node *node, S_Deleter deleter):
903  Schema_Node(node, deleter),
904  node(node),
905  deleter(deleter)
906  {};
907  ~Schema_Node_Case();
909  S_When when();
910 
911 private:
912  struct lys_node *node;
913  S_Deleter deleter;
914 };
915 
917 {
918 public:
919  Schema_Node_Inout(S_Schema_Node derived):
920  Schema_Node(derived->node, derived->deleter),
921  node(derived->node),
922  deleter(derived->deleter)
923  {
924  if (derived->node->nodetype != LYS_INPUT && derived->node->nodetype != LYS_OUTPUT) {
925  throw std::invalid_argument("Type must be LYS_INOUT or LYS_OUTPUT");
926  }
927  };
929  Schema_Node_Inout(struct lys_node *node, S_Deleter deleter):
930  Schema_Node(node, deleter),
931  node(node),
932  deleter(deleter)
933  {};
936  uint8_t tpdf_size() {return ((struct lys_node_inout *)node)->tpdf_size;};
938  uint8_t must_size() {return ((struct lys_node_inout *)node)->must_size;};
940  std::vector<S_Tpdf> tpdf();
942  std::vector<S_Restr> must();
943 
944 private:
945  struct lys_node *node;
946  S_Deleter deleter;
947 };
948 
950 {
951 public:
952  Schema_Node_Notif(S_Schema_Node derived):
953  Schema_Node(derived->node, derived->deleter),
954  node(derived->node),
955  deleter(derived->deleter)
956  {
957  if (derived->node->nodetype != LYS_NOTIF) {
958  throw std::invalid_argument("Type must be LYS_NOTIF");
959  }
960  };
962  Schema_Node_Notif(struct lys_node *node, S_Deleter deleter):
963  Schema_Node(node, deleter),
964  node(node),
965  deleter(deleter)
966  {};
969  uint8_t tpdf_size() {return ((struct lys_node_notif *)node)->tpdf_size;};
971  uint8_t must_size() {return ((struct lys_node_notif *)node)->must_size;};
973  std::vector<S_Tpdf> tpdf();
975  std::vector<S_Restr> must();
976 
977 private:
978  struct lys_node *node;
979  S_Deleter deleter;
980 };
981 
983 {
984 public:
985  Schema_Node_Rpc_Action(S_Schema_Node derived):
986  Schema_Node(derived->node, derived->deleter),
987  node(derived->node),
988  deleter(derived->deleter)
989  {
990  if (derived->node->nodetype != LYS_ACTION && derived->node->nodetype != LYS_RPC) {
991  throw std::invalid_argument("Type must be LYS_ACTION or LYS_RPC");
992  }
993  };
995  Schema_Node_Rpc_Action(struct lys_node *node, S_Deleter deleter):
996  Schema_Node(node, deleter),
997  node(node),
998  deleter(deleter)
999  {};
1002  uint8_t tpdf_size() {return ((struct lys_node_rpc_action *)node)->tpdf_size;};
1004  std::vector<S_Tpdf> tpdf();
1005 
1006 private:
1007  struct lys_node *node;
1008  S_Deleter deleter;
1009 };
1010 
1012 {
1013 public:
1014  Schema_Node_Augment(S_Schema_Node derived):
1015  Schema_Node(derived->node, derived->deleter),
1016  node(derived->node),
1017  deleter(derived->deleter)
1018  {
1019  if (derived->node->nodetype != LYS_AUGMENT) {
1020  throw std::invalid_argument("Type must be LYS_AUGMENT");
1021  }
1022  };
1024  Schema_Node_Augment(struct lys_node *node, S_Deleter deleter):
1025  Schema_Node(node, deleter),
1026  node(node),
1027  deleter(deleter)
1028  {};
1031  S_When when();
1033  S_Schema_Node target() LY_NEW_CASTED(lys_node_augment, node, target, Schema_Node);
1034 
1035 private:
1036  struct lys_node *node;
1037  S_Deleter deleter;
1038 };
1039 
1040 class Substmt
1041 {
1042 public:
1044  Substmt(struct lyext_substmt *substmt, S_Deleter deleter);
1045  ~Substmt();
1047  LY_STMT stmt() {return substmt->stmt;};
1049  size_t offset() {return substmt->offset;};
1051  LY_STMT_CARD cardinality() {return substmt->cardinality;};
1052 private:
1053  struct lyext_substmt *substmt;
1054  S_Deleter deleter;
1055 };
1056 
1057 class Ext
1058 {
1059 public:
1061  Ext(struct lys_ext *ext, S_Deleter deleter);
1062  ~Ext();
1064  const char *name() {return ext->name;};
1066  const char *dsc() {return ext->dsc;};
1068  const char *ref() {return ext->ref;};
1070  uint16_t flags() {return ext->flags;};
1072  uint8_t ext_size() {return ext->ext_size;};
1074  std::vector<S_Ext_Instance> ext_instance();
1076  const char *argument() {return ext->argument;};
1078  S_Module module();
1079  //struct lyext_plugin *plugin;
1080 private:
1081  struct lys_ext *ext;
1082  S_Deleter deleter;
1083 };
1084 
1086 {
1087 public:
1089  Refine_Mod_List(struct lys_refine_mod_list *list, S_Deleter deleter);
1090  ~Refine_Mod_List();
1092  uint32_t min() {return list->min;};
1094  uint32_t max() {return list->max;};
1095 
1096 private:
1097  struct lys_refine_mod_list *list;
1098  S_Deleter deleter;
1099 };
1100 
1102 {
1103 public:
1105  Refine_Mod(union lys_refine_mod mod, uint16_t target_type, S_Deleter deleter);
1106  ~Refine_Mod();
1108  const char *presence() {return target_type == LYS_CONTAINER ? mod.presence : nullptr;};
1110  S_Refine_Mod_List list();
1111 
1112 private:
1113  union lys_refine_mod mod;
1114  uint16_t target_type;
1115  S_Deleter deleter;
1116 };
1117 
1118 class Refine
1119 {
1120 public:
1122  Refine(struct lys_refine *refine, S_Deleter deleter);
1123  ~Refine();
1125  const char *target_name() {return refine->target_name;};
1127  const char *dsc() {return refine->dsc;};
1129  const char *ref() {return refine->ref;};
1131  uint16_t flags() {return refine->flags;};
1133  uint8_t ext_size() {return refine->ext_size;};
1135  uint8_t iffeature_size() {return refine->iffeature_size;};
1137  uint16_t target_type() {return refine->target_type;};
1139  uint8_t must_size() {return refine->must_size;};
1141  uint8_t dflt_size() {return refine->dflt_size;};
1143  std::vector<S_Ext_Instance> ext();
1145  std::vector<S_Iffeature> iffeature() LY_NEW_LIST(refine, iffeature, iffeature_size, Iffeature);
1147  S_Module module();
1149  std::vector<S_Restr> must();
1151  std::vector<std::string> dflt() LY_NEW_STRING_LIST(refine, dflt, dflt_size);
1153  S_Refine_Mod mod();
1154 
1155 private:
1156  struct lys_refine *refine;
1157  S_Deleter deleter;
1158 };
1159 
1160 class Deviate
1161 {
1162 public:
1164  Deviate(struct lys_deviate *deviate, S_Deleter deleter);
1165  ~Deviate();
1167  LYS_DEVIATE_TYPE mod() {return deviate->mod;};
1169  uint8_t flags() {return deviate->flags;};
1171  uint8_t dflt_size() {return deviate->dflt_size;};
1173  uint8_t ext_size() {return deviate->ext_size;};
1175  uint8_t min_set() {return deviate->min_set;};
1177  uint8_t max_set() {return deviate->max_set;};
1179  uint8_t must_size() {return deviate->must_size;};
1181  uint8_t unique_size() {return deviate->unique_size;};
1183  uint32_t min() {return deviate->min;};
1185  uint32_t max() {return deviate->max;};
1187  S_Restr must();
1189  S_Unique unique();
1191  S_Type type();
1193  const char *units() {return deviate->units;};
1195  std::vector<std::string> dflt() LY_NEW_STRING_LIST(deviate, dflt, dflt_size);
1197  std::vector<S_Ext_Instance> ext();
1198 
1199 private:
1200  struct lys_deviate *deviate;
1201  S_Deleter deleter;
1202 };
1203 
1205 {
1206 public:
1208  Deviation(struct lys_deviation *deviation, S_Deleter deleter);
1209  ~Deviation();
1211  const char *target_name() {return deviation->target_name;};
1213  const char *dsc() {return deviation->dsc;};
1215  const char *ref() {return deviation->ref;};
1217  S_Schema_Node orig_node();
1219  uint8_t deviate_size() {return deviation->deviate_size;};
1221  uint8_t ext_size() {return deviation->ext_size;};
1223  std::vector<S_Deviate> deviate();
1225  std::vector<S_Ext_Instance> ext();
1226 
1227 private:
1228  struct lys_deviation *deviation;
1229  S_Deleter deleter;
1230 };
1231 
1232 class Import
1233 {
1234 public:
1236  Import(struct lys_import *import, S_Deleter deleter);
1237  ~Import();
1239  S_Module module() LY_NEW(import, module, Module);
1241  const char *prefix() {return import->prefix;};
1243  char *rev() {return &import->rev[0];};
1245  uint8_t ext_size() {return import->ext_size;};
1247  std::vector<S_Ext_Instance> ext() LY_NEW_P_LIST(import, ext, ext_size, Ext_Instance);
1249  const char *dsc() {return import->dsc;};
1251  const char *ref() {return import->ref;};
1252 
1253 private:
1254  struct lys_import *import;
1255  S_Deleter deleter;
1256 };
1257 
1258 class Include
1259 {
1260 public:
1262  Include(struct lys_include *include, S_Deleter deleter);
1263  ~Include();
1265  S_Submodule submodule() LY_NEW(include, submodule, Submodule);
1267  char *rev() {return &include->rev[0];};
1269  uint8_t ext_size() {return include->ext_size;};
1271  std::vector<S_Ext_Instance> ext() LY_NEW_P_LIST(include, ext, ext_size, Ext_Instance);
1273  const char *dsc() {return include->dsc;};
1275  const char *ref() {return include->ref;};
1276 
1277 private:
1278  struct lys_include *include;
1279  S_Deleter deleter;
1280 };
1281 
1283 {
1284 public:
1286  Revision(lys_revision *revision, S_Deleter deleter);
1287  ~Revision();
1289  char *date() {return &revision->date[0];};
1291  uint8_t ext_size() {return revision->ext_size;};
1293  const char *dsc() {return revision->dsc;};
1295  const char *ref() {return revision->ref;};
1296 
1297 private:
1298  struct lys_revision *revision;
1299  S_Deleter deleter;
1300 };
1301 
1302 class Tpdf
1303 {
1304 public:
1306  Tpdf(struct lys_tpdf *tpdf, S_Deleter deleter);
1307  ~Tpdf();
1309  const char *name() {return tpdf->name;};
1311  const char *dsc() {return tpdf->dsc;};
1313  const char *ref() {return tpdf->ref;};
1315  uint16_t flags() {return tpdf->flags;};
1317  uint8_t ext_size() {return tpdf->ext_size;};
1319  uint8_t padding_iffsize() {return tpdf->padding_iffsize;};
1321  uint8_t has_union_leafref() {return tpdf->has_union_leafref;};
1323  std::vector<S_Ext_Instance> ext() LY_NEW_P_LIST(tpdf, ext, ext_size, Ext_Instance);
1325  const char *units() {return tpdf->units;};
1327  S_Module module() LY_NEW(tpdf, module, Module);
1329  S_Type type();
1331  const char *dflt() {return tpdf->dflt;};
1332 
1333 private:
1334  struct lys_tpdf *tpdf;
1335  S_Deleter deleter;
1336 };
1337 
1338 class Unique
1339 {
1340 public:
1342  Unique(struct lys_unique *unique, S_Deleter deleter);
1343  ~Unique();
1345  std::vector<std::string> expr() LY_NEW_STRING_LIST(unique, expr, expr_size);
1347  uint8_t expr_size() {return unique->expr_size;};
1349  uint8_t trg_type() {return unique->trg_type;};
1350 
1351 private:
1352  struct lys_unique *unique;
1353  S_Deleter deleter;
1354 };
1355 
1356 class Feature
1357 {
1358 public:
1360  Feature(struct lys_feature *feature, S_Deleter);
1361  ~Feature();
1363  const char *name() {return feature->name;};
1365  const char *dsc() {return feature->dsc;};
1367  const char *ref() {return feature->ref;};
1369  uint16_t flags() {return feature->flags;};
1371  uint8_t ext_size() {return feature->ext_size;};
1373  uint8_t iffeature_size() {return feature->iffeature_size;};
1375  std::vector<S_Ext_Instance> ext() LY_NEW_P_LIST(feature, ext, ext_size, Ext_Instance);
1377  std::vector<S_Iffeature> iffeature() LY_NEW_LIST(feature, iffeature, iffeature_size, Iffeature);
1379  S_Module module() LY_NEW(feature, module, Module);
1381  S_Set depfeatures() LY_NEW(feature, depfeatures, Set);
1382 
1383 private:
1384  struct lys_feature *feature;
1385  S_Deleter deleter;
1386 };
1387 
1388 class Restr
1389 {
1390 public:
1392  Restr(struct lys_restr *restr, S_Deleter deleter);
1393  ~Restr();
1395  const char *expr() {return restr->expr;};
1397  const char *dsc() {return restr->dsc;};
1399  const char *ref() {return restr->ref;};
1401  const char *eapptag() {return restr->eapptag;};
1403  const char *emsg() {return restr->emsg;};
1405  std::vector<S_Ext_Instance> ext() LY_NEW_P_LIST(restr, ext, ext_size, Ext_Instance);
1407  uint8_t ext_size() {return restr->ext_size;};
1408 
1409 private:
1410  struct lys_restr *restr;
1411  S_Deleter deleter;
1412 };
1413 
1414 class When
1415 {
1416 public:
1418  When(struct lys_when *when, S_Deleter deleter = nullptr);
1419  ~When();
1421  const char *cond() {return when->cond;};
1423  const char *dsc() {return when->dsc;};
1425  const char *ref() {return when->ref;};
1427  std::vector<S_Ext_Instance> ext();
1429  uint8_t ext_size() {return when->ext_size;};
1430 
1431 private:
1432  struct lys_when *when;
1433  S_Deleter deleter;
1434 };
1435 
1436 class Ident
1437 {
1438 public:
1440  Ident(struct lys_ident *ident, S_Deleter deleter);
1441  ~Ident();
1443  const char *name() {return ident->name;};
1445  const char *dsc() {return ident->dsc;};
1447  const char *ref() {return ident->ref;};
1449  uint16_t flags() {return ident->flags;};
1451  uint8_t ext_size() {return ident->ext_size;};
1453  uint8_t iffeature_size() {return ident->iffeature_size;};
1455  uint8_t base_size() {return ident->base_size;};
1457  std::vector<S_Ext_Instance> ext() LY_NEW_P_LIST(ident, ext, ext_size, Ext_Instance);
1459  std::vector<S_Iffeature> iffeature() LY_NEW_LIST(ident, iffeature, iffeature_size, Iffeature);
1461  S_Module module() LY_NEW(ident, module, Module);
1463  std::vector<S_Ident> base();
1465  S_Set der() LY_NEW(ident, der, Set);
1466 
1467 private:
1468  struct lys_ident *ident;
1469  S_Deleter deleter;
1470 };
1471 
1474 }
1475 
1476 #endif
uint8_t augment_size
Definition: tree_schema.h:708
const char * ref()
const char * ref
Definition: tree_schema.h:455
Common structure representing single YANG data statement describing.
Definition: tree_schema.h:1229
const char * ref()
const char * emsg
Definition: tree_schema.h:2079
Schema_Node_Leaflist(S_Schema_Node derived)
uint16_t flags()
std::vector< S_Ext_Instance > ext()
LY_STMT_CARD cardinality
Definition: tree_schema.h:446
LY_STMT_CARD
Possible cardinalities of the YANG statements.
Definition: tree_schema.h:382
Schema leaf node structure.
Definition: tree_schema.h:1365
uint8_t augment_size()
Schema grouping node structure.
Definition: tree_schema.h:1628
uint8_t iffeature_size()
S_Module module()
const char * contact()
const char * ref()
uint8_t implemented
Definition: tree_schema.h:756
LYS_DEVIATE_TYPE mod()
uint8_t ext_size()
unsigned int count
Definition: tree_schema.h:849
uint16_t target_type()
std::vector< S_Ext_Instance > ext()
Schema_Node_Container(struct lys_node *node, S_Deleter deleter)
Schema_Node_Case(S_Schema_Node derived)
Submodule schema node structure that can be included into a YANG module.
Definition: tree_schema.h:737
const char * ref()
S_Module module()
uint16_t flags()
uint8_t type
Definition: tree_schema.h:683
uint8_t ident_size()
Definition: Tree_Schema.hpp:79
S_Revision rev()
Definition: Tree_Schema.cpp:36
Module(struct lys_module *module, S_Deleter deleter)
Definition: Tree_Schema.cpp:31
const char * target_name
Definition: tree_schema.h:1898
const char * arg_value
Definition: tree_schema.h:478
uint8_t tpdf_size()
Definition: Tree_Schema.hpp:81
const char * dsc()
uint8_t trg_type
Definition: tree_schema.h:2045
uint8_t deviated
Definition: tree_schema.h:688
std::vector< S_Iffeature > iffeature()
uint8_t iffeature_size
Definition: tree_schema.h:835
Schema_Node_Uses(struct lys_node *node, S_Deleter deleter)
const char * cond
Definition: tree_schema.h:2089
const char * target_name()
YANG uses&#39;s refine substatement structure, see RFC 6020 sec. 7.12.2
Definition: tree_schema.h:1897
Schema_Node_Rpc_Action(S_Schema_Node derived)
const char * ref()
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
uint8_t unique_size()
uint8_t rev_size()
Definition: Tree_Schema.hpp:73
Container for list modifications in lys_refine_mod.
Definition: tree_schema.h:1880
const char * filepath()
const char * name()
Container for information about string types (LY_TYPE_STRING), used in lys_type_info.
Definition: tree_schema.h:935
uint8_t trg_type()
std::vector< std::string > expr()
std::vector< std::string > dflt()
libyang representation of data model trees.
classes for wrapping lys_submodule.
uint8_t ext_size()
uint8_t extensions_size()
const char * ref()
const char * dsc()
S_Deleter swig_deleter()
uint8_t inc_size()
Definition: Tree_Schema.hpp:77
unsigned int pat_count
Definition: tree_schema.h:944
YANG typedef structure providing information from the schema.
Definition: tree_schema.h:2017
std::vector< S_Ext_Instance > ext()
uint8_t min_set
Definition: tree_schema.h:1945
lyxp_node_type
Types of context nodes, LYXP_NODE_ROOT_CONFIG used only in when or must conditions.
Definition: tree_schema.h:2311
const char * target_name()
Schema_Node_Inout(struct lys_node *node, S_Deleter deleter)
std::vector< S_Iffeature > iffeature()
Single enumeration value specification for lys_type_info_enums.
Definition: tree_schema.h:868
Schema_Node_Rpc_Action(struct lys_node *node, S_Deleter deleter)
const char * dsc()
uint8_t must_size
Definition: tree_schema.h:1909
const char * prefix
Definition: tree_schema.h:677
const char * ns()
Definition: Tree_Schema.hpp:93
Union for holding type-specific information in lys_type.
Definition: tree_schema.h:965
int validate_value(const char *value)
Container for information about leafref types (LY_TYPE_LEAFREF), used in lys_type_info.
Definition: tree_schema.h:922
class for wrapping ly_ctx.
Definition: Libyang.hpp:43
uint16_t flags()
uint8_t version()
Definition: Tree_Schema.hpp:67
Schema_Node_Anydata(S_Schema_Node derived)
const char * dsc()
Compiled if-feature expression structure.
Definition: tree_schema.h:1078
Schema_Node_Grp(S_Schema_Node derived)
S_Schema_Node child() override
std::vector< S_Ext_Instance > ext()
Schema leaf-list node structure.
Definition: tree_schema.h:1418
Schema_Node_List(S_Schema_Node derived)
const char * contact
Definition: tree_schema.h:681
uint8_t disabled()
Definition: Tree_Schema.hpp:71
YANG augment structure (covering both possibilities - uses&#39;s substatement as well as (sub)module&#39;s su...
Definition: tree_schema.h:1845
uint8_t inc_size
Definition: tree_schema.h:702
LYS_OUTFORMAT
Schema output formats accepted by libyang printer functions.
Definition: tree_schema.h:204
uint8_t has_union_leafref()
uint8_t max_set
Definition: tree_schema.h:1946
LYS_DEVIATE_TYPE mod
Definition: tree_schema.h:1939
const char * dsc()
Definition: Tree_Schema.hpp:55
Container for information about enumeration types (LY_TYPE_ENUM), used in lys_type_info.
Definition: tree_schema.h:887
uint16_t ident_size
Definition: tree_schema.h:704
Container for information about integer types, used in lys_type_info.
Definition: tree_schema.h:914
uint8_t flags
Definition: tree_schema.h:1941
const char * ref()
The main libyang public header.
LY_STMT stmt
Definition: tree_schema.h:444
const char * argument
Definition: tree_schema.h:460
std::vector< S_Ext_Instance > ext()
const char * eapptag()
const char * dsc
Definition: tree_schema.h:454
Union to hold target modification in lys_refine.
Definition: tree_schema.h:1888
const char * name()
Container for information about decimal64 types (LY_TYPE_DEC64), used in lys_type_info.
Definition: tree_schema.h:855
uint8_t insubstmt_index
Definition: tree_schema.h:481
const char * ref()
Definition: Tree_Schema.hpp:57
struct lys_ext_instance ** ext
Definition: tree_schema.h:459
uint8_t has_union_leafref
Definition: tree_schema.h:2024
const char * dsc()
uint8_t iffeature_size()
std::vector< S_Ext_Instance > ext()
const char * ref
Definition: tree_schema.h:679
const char * presence()
Schema_Node_Leaflist(struct lys_node *node, S_Deleter deleter)
const char * ref()
std::vector< S_Deviation > deviation()
Definition: Tree_Schema.cpp:37
Schema_Node_Choice(S_Schema_Node derived)
const char * dsc()
Schema_Node_Choice(struct lys_node *node, S_Deleter deleter)
const char * filepath
Definition: tree_schema.h:682
const char * dsc()
const char * dsc()
const char * name()
const char * ref()
Container for information about identity types (LY_TYPE_IDENT), used in lys_type_info.
Definition: tree_schema.h:895
uint8_t ext_size()
Definition: Tree_Schema.hpp:91
uint8_t padding_iffsize()
YANG when restriction, see RFC 6020 sec. 7.19.5
Definition: tree_schema.h:2088
const char * ref()
Container for information about bits types (LY_TYPE_BINARY), used in lys_type_info.
Definition: tree_schema.h:847
uint8_t * expr
Definition: tree_schema.h:1079
S_Schema_Node data()
Definition: Tree_Schema.hpp:99
const char * dsc()
Schema_Node_List(struct lys_node *node, S_Deleter deleter)
const char * ref()
const char * emsg()
classes for wrapping lyd_node.
Definition: Tree_Data.hpp:97
Schema list node structure.
Definition: tree_schema.h:1474
uint8_t features_size
Definition: tree_schema.h:707
const char * ns
Definition: tree_schema.h:727
LY_STMT_CARD cardinality()
const char * argument()
uint8_t iffeature_size()
uint8_t features_size()
const char * name()
const char * dsc()
const char * dsc()
const char * units()
Container for information about instance-identifier types (LY_TYPE_INST), used in lys_type_info...
Definition: tree_schema.h:903
const char * org()
Definition: Tree_Schema.hpp:59
Main schema node structure representing YANG module.
Definition: tree_schema.h:674
uint8_t dflt_size
Definition: tree_schema.h:1910
S_Schema_Node child() override
uint8_t devaiation_size()
Definition: Tree_Schema.hpp:87
uint8_t iffeature_size()
Schema_Node_Augment(struct lys_node *node, S_Deleter deleter)
const char * name()
uint16_t flags()
const char * prefix()
Definition: Tree_Schema.hpp:53
uint32_t pos
Definition: tree_schema.h:838
Schema_Node_Grp(struct lys_node *node, S_Deleter deleter)
uint8_t unique_size
Definition: tree_schema.h:1948
Class implementation for libyang C header libyang.h.
RPC input and output node structure.
Definition: tree_schema.h:1712
uint8_t version
Definition: tree_schema.h:684
LY_DATA_TYPE
YANG built-in types.
Definition: tree_schema.h:792
uint8_t type()
Definition: Tree_Schema.hpp:65
uint8_t ext_size
Definition: tree_schema.h:711
const char * name()
Schema_Node_Leaf(struct lys_node *node, S_Deleter deleter)
uint8_t augment_size()
Definition: Tree_Schema.hpp:85
std::string print_mem(LYS_OUTFORMAT format, int options)
Definition: Tree_Schema.cpp:52
uint16_t flags
Definition: tree_schema.h:832
YANG type structure providing information from the schema.
Definition: tree_schema.h:981
char date[11]
Definition: tree_schema.h:2007
const char * filepath()
Definition: Tree_Schema.hpp:63
uint8_t ext_size()
uint8_t dflt_size()
const char * ref()
const char * ref()
YANG list&#39;s unique statement structure, see RFC 6020 sec. 7.8.3
Definition: tree_schema.h:2042
struct lys_node * swig_node()
uint8_t imp_size
Definition: tree_schema.h:701
Structure to hold information about identity, see RFC 6020 sec. 7.16
Definition: tree_schema.h:2102
Schema_Node_Augment(S_Schema_Node derived)
const char * cond()
const char * org
Definition: tree_schema.h:680
Description of the extension instance substatement.
Definition: tree_schema.h:443
uint8_t rev_size
Definition: tree_schema.h:700
Schema_Node_Container(S_Schema_Node derived)
uint8_t ext_size()
const char * org()
uint8_t extensions_size()
Definition: Tree_Schema.hpp:89
uint8_t base_size()
YANG deviate statement structure, see RFC 6020 sec. 7.18.3.2
Definition: tree_schema.h:1938
uint8_t imp_size()
Definition: Tree_Schema.hpp:75
int lyd_validate_value(struct lys_node *node, const char *value)
Check restrictions applicable to the particular leaf/leaf-list on the given string value...
const char * name()
S_Module belongsto()
const char * ref()
uint8_t base_size
Definition: tree_schema.h:2112
const char * name
Definition: tree_schema.h:453
uint8_t extensions_size
Definition: tree_schema.h:710
const char * presence
Definition: tree_schema.h:1889
Schema uses node structure.
Definition: tree_schema.h:1581
S_Submodule submodule()
const char * units
Definition: tree_schema.h:1956
uint8_t ext_size()
Schema_Node_Notif(S_Schema_Node derived)
Schema notification node structure.
Definition: tree_schema.h:1750
const char * dsc()
const char * name
Definition: tree_schema.h:676
Schema_Node_Leaf(S_Schema_Node derived)
LY_STMT
List of YANG statements.
Definition: tree_schema.h:290
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
Schema_Node_Inout(S_Schema_Node derived)
const char * contact()
Definition: Tree_Schema.hpp:61
uint8_t iffeature_size()
uint8_t must_size()
uint8_t deviation_size()
uint8_t features_size()
Definition: Tree_Schema.hpp:83
int32_t value
Definition: tree_schema.h:878
const char * arg_value()
enum lys_deviate_type LYS_DEVIATE_TYPE
Possible deviation modifications, see RFC 6020 sec. 7.18.3.2
Schema rpc/action node structure.
Definition: tree_schema.h:1797
uint8_t padding_iffsize
Definition: tree_schema.h:2023
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
uint8_t ext_size()
const char * prefix()
uint8_t parent_type
Definition: tree_schema.h:491
Schema_Node_Notif(struct lys_node *node, S_Deleter deleter)
YANG extension definition.
Definition: tree_schema.h:452
const char * dsc()
const char * expr()
uint8_t disabled
Definition: tree_schema.h:692
YANG revision statement for (sub)modules.
Definition: tree_schema.h:2006
YANG include structure used to reference submodules.
Definition: tree_schema.h:1994
YANG feature definition structure.
Definition: tree_schema.h:2051
uint16_t tpdf_size
Definition: tree_schema.h:705
const char * eapptag
Definition: tree_schema.h:2078
const char * path
Definition: tree_schema.h:923
enum lys_nodetype LYS_NODE
YANG schema node types.
Schema_Node_Uses(S_Schema_Node derived)
Single bit value specification for lys_type_info_bits.
Definition: tree_schema.h:828
uint8_t ext_size()
const char * ref()
uint16_t target_type
Definition: tree_schema.h:1906
uint8_t deviation_size
Definition: tree_schema.h:709
classes for wrapping lys_module.
Definition: Tree_Schema.hpp:44
const char * name()
Definition: Tree_Schema.hpp:51
const char * dsc
Definition: tree_schema.h:678
Schema_Node_Anydata(struct lys_node *node, S_Deleter deleter)
Schema_Node_Case(struct lys_node *node, S_Deleter deleter)
Schema container node structure.
Definition: tree_schema.h:1275
YANG deviation statement structure, see RFC 6020 sec. 7.18.3
Definition: tree_schema.h:1965
const char * expr
Definition: tree_schema.h:2073
LY_DATA_TYPE base()
uint8_t deviated()
Definition: Tree_Schema.hpp:69