23 #include "Internal.hpp"
55 const char *
dsc() {
return module->
dsc;};
57 const char *
ref() {
return module->
ref;};
59 const char *
org() {
return module->
org;};
95 const char *
ns() {
return module->
ns;};
136 const
char *
name() {
return submodule->name;};
140 const char *
dsc() {
return submodule->
dsc;};
142 const char *
ref() {
return submodule->
ref;};
144 const char *
org() {
return submodule->
org;};
214 const char *
dsc() {
return info_bit->
dsc;};
216 const char *
ref() {
return info_bit->
ref;};
226 std::vector<S_Ext_Instance> ext();
228 std::vector<S_Iffeature> iffeature();
242 std::vector<S_Type_Bit> bit();
278 const char *
dsc() {
return info_enum->
dsc;};
280 const char *
ref() {
return info_enum->
ref;};
290 std::vector<S_Ext_Instance> ext();
292 std::vector<S_Iffeature> iffeature();
306 std::vector<S_Type_Enum> enm();
322 std::vector<S_Ident>
ref();
368 S_Schema_Node_Leaf target();
402 std::vector<S_Type> types();
420 S_Type_Info_Binary binary();
422 S_Type_Info_Bits bits();
424 S_Type_Info_Dec64 dec64();
426 S_Type_Info_Enums enums();
428 S_Type_Info_Ident ident();
430 S_Type_Info_Inst inst();
432 S_Type_Info_Num num();
434 S_Type_Info_Lref lref();
436 S_Type_Info_Str str();
438 S_Type_Info_Union uni();
458 std::vector<S_Ext_Instance> ext();
481 std::vector<S_Ext_Instance> ext();
512 std::vector<S_Ext_Instance> ext();
514 S_Ext
def() LY_NEW(ext_instance, def,
Ext);
516 void *priv() {
return ext_instance->priv;};
520 LYS_NODE nodetype() {
return ext_instance->nodetype;};
545 std::vector<S_Ext_Instance> ext();
553 virtual S_Schema_Node parent();
555 virtual S_Schema_Node child();
557 virtual S_Schema_Node next();
559 virtual S_Schema_Node prev();
562 std::string path(
int options = 0);
566 std::vector<S_Schema_Node> child_instantiables(
int options);
568 S_Set find_path(
const char *path);
570 S_Set xpath_atomize(
enum lyxp_node_type ctx_node_type,
const char *expr,
int options);
572 S_Set xpath_atomize(
int options);
577 std::vector<S_Schema_Node> tree_for();
579 std::vector<S_Schema_Node> tree_dfs();
614 deleter(derived->deleter)
617 throw std::invalid_argument(
"Type must be LYS_CONTAINER");
647 deleter(derived->deleter)
650 throw std::invalid_argument(
"Type must be LYS_CHOICE");
663 S_Schema_Node dflt();
676 deleter(derived->deleter)
678 if (derived->node->nodetype !=
LYS_LEAF) {
679 throw std::invalid_argument(
"Type must be LYS_LEAF");
697 S_Schema_Node
child()
override {
return nullptr;};
699 S_Schema_Node_List is_key();
712 deleter(derived->deleter)
715 throw std::invalid_argument(
"Type must be LYS_LEAFLIST");
732 std::vector<S_Restr> must();
738 std::vector<std::string> dflt();
743 S_Schema_Node
child()
override {
return nullptr;};
756 deleter(derived->deleter)
758 if (derived->node->nodetype !=
LYS_LIST) {
759 throw std::invalid_argument(
"Type must be LYS_LIST");
780 std::vector<S_Restr> must();
782 std::vector<S_Tpdf> tpdf();
784 std::vector<S_Schema_Node_Leaf> keys();
786 std::vector<S_Unique> unique();
805 deleter(derived->deleter)
808 throw std::invalid_argument(
"Type must be LYS_ANYDATA or LYS_ANYXML");
823 std::vector<S_Restr> must();
836 deleter(derived->deleter)
838 if (derived->node->nodetype !=
LYS_USES) {
839 throw std::invalid_argument(
"Type must be LYS_USES");
854 std::vector<S_Refine> refine();
856 std::vector<S_Schema_Node_Augment> augment();
858 S_Schema_Node_Grp grp();
871 deleter(derived->deleter)
874 throw std::invalid_argument(
"Type must be LYS_GROUPING");
887 std::vector<S_Tpdf> tpdf();
900 deleter(derived->deleter)
902 if (derived->node->nodetype !=
LYS_CASE) {
903 throw std::invalid_argument(
"Type must be LYS_CASE");
927 deleter(derived->deleter)
930 throw std::invalid_argument(
"Type must be LYS_INOUT or LYS_OUTPUT");
945 std::vector<S_Tpdf> tpdf();
947 std::vector<S_Restr> must();
960 deleter(derived->deleter)
962 if (derived->node->nodetype !=
LYS_NOTIF) {
963 throw std::invalid_argument(
"Type must be LYS_NOTIF");
978 std::vector<S_Tpdf> tpdf();
980 std::vector<S_Restr> must();
993 deleter(derived->deleter)
995 if (derived->node->nodetype !=
LYS_ACTION && derived->node->nodetype !=
LYS_RPC) {
996 throw std::invalid_argument(
"Type must be LYS_ACTION or LYS_RPC");
1009 std::vector<S_Tpdf> tpdf();
1021 node(derived->node),
1022 deleter(derived->deleter)
1025 throw std::invalid_argument(
"Type must be LYS_AUGMENT");
1079 std::vector<S_Ext_Instance> ext_instance();
1115 S_Refine_Mod_List list();
1119 uint16_t target_type;
1148 std::vector<S_Ext_Instance> ext();
1154 std::vector<S_Restr> must();
1156 std::vector<std::
string> dflt() LY_NEW_STRING_LIST(refine, dflt, dflt_size);
1200 std::vector<std::string>
dflt() LY_NEW_STRING_LIST(deviate, dflt, dflt_size);
1202 std::vector<S_Ext_Instance> ext();
1222 S_Schema_Node orig_node();
1228 std::vector<S_Deviate> deviate();
1230 std::vector<S_Ext_Instance> ext();
1246 const
char *
prefix() {
return import->prefix;};
1248 char *
rev() {
return &
import->rev[0];};
1254 const
char *
dsc() {
return import->dsc;};
1256 const char *
ref() {
return import->ref;};
1272 char *
rev() {
return &include->rev[0];};
1278 const
char *
dsc() {
return include->dsc;};
1330 const
char *units() {
return tpdf->units;};
1336 const
char *dflt() {
return tpdf->dflt;};
1350 std::vector<std::string>
expr() LY_NEW_STRING_LIST(unique, expr, expr_size);
1352 uint8_t expr_size() {
return unique->expr_size;};
1382 std::vector<S_Iffeature> iffeature() LY_NEW_LIST(feature, iffeature, iffeature_size,
Iffeature);
1384 S_Module module() LY_NEW(feature, module,
Module);
1386 S_Set depfeatures() LY_NEW(feature, depfeatures,
Set);
1423 When(
struct lys_when *when, S_Deleter deleter =
nullptr);
1432 std::vector<S_Ext_Instance> ext();
1464 std::vector<S_Iffeature> iffeature() LY_NEW_LIST(ident, iffeature, iffeature_size,
Iffeature);
1466 S_Module module() LY_NEW(ident, module,
Module);
1468 std::vector<S_Ident> base();
1470 S_Set der() LY_NEW(ident, der,
Set);
Class implementation for libyang C header libyang.h.
class for wrapping ly_ctx.
classes for wrapping lyd_node.
std::vector< std::string > dflt()
const char * target_name()
uint8_t insubstmt_index()
std::vector< S_Ext_Instance > ext()
std::vector< S_Ext_Instance > ext()
std::vector< S_Ext_Instance > ext()
std::vector< S_Ext_Instance > ext()
classes for wrapping lys_module.
int feature_disable(const char *feature)
std::string print_mem(LYS_OUTFORMAT format, int options)
Module(struct lys_module *module, S_Deleter deleter)
int feature_state(const char *feature)
std::vector< S_Deviation > deviation()
uint8_t extensions_size()
std::vector< S_Schema_Node > data_instantiables(int options)
uint8_t devaiation_size()
int feature_enable(const char *feature)
const char * target_name()
std::vector< S_Iffeature > iffeature()
std::vector< S_Ext_Instance > ext()
Schema_Node_Anydata(struct lys_node *node, S_Deleter deleter)
Schema_Node_Anydata(S_Schema_Node derived)
Schema_Node_Augment(struct lys_node *node, S_Deleter deleter)
Schema_Node_Augment(S_Schema_Node derived)
Schema_Node_Case(struct lys_node *node, S_Deleter deleter)
Schema_Node_Case(S_Schema_Node derived)
Schema_Node_Choice(struct lys_node *node, S_Deleter deleter)
Schema_Node_Choice(S_Schema_Node derived)
Schema_Node_Container(struct lys_node *node, S_Deleter deleter)
Schema_Node_Container(S_Schema_Node derived)
Schema_Node_Grp(struct lys_node *node, S_Deleter deleter)
Schema_Node_Grp(S_Schema_Node derived)
Schema_Node_Inout(struct lys_node *node, S_Deleter deleter)
Schema_Node_Inout(S_Schema_Node derived)
S_Schema_Node child() override
Schema_Node_Leaf(struct lys_node *node, S_Deleter deleter)
Schema_Node_Leaf(S_Schema_Node derived)
S_Schema_Node child() override
Schema_Node_Leaflist(struct lys_node *node, S_Deleter deleter)
Schema_Node_Leaflist(S_Schema_Node derived)
Schema_Node_List(S_Schema_Node derived)
Schema_Node_List(struct lys_node *node, S_Deleter deleter)
Schema_Node_Notif(S_Schema_Node derived)
Schema_Node_Notif(struct lys_node *node, S_Deleter deleter)
Schema_Node_Rpc_Action(S_Schema_Node derived)
Schema_Node_Rpc_Action(struct lys_node *node, S_Deleter deleter)
Schema_Node_Uses(struct lys_node *node, S_Deleter deleter)
Schema_Node_Uses(S_Schema_Node derived)
struct lys_node * swig_node()
friend Schema_Node_Action
friend Schema_Node_Leaflist
std::vector< S_Iffeature > iffeature()
friend Schema_Node_Augment
friend Schema_Node_Rpc_Action
friend Schema_Node_Anydata
friend Schema_Node_Container
int validate_value(const char *value)
friend Schema_Node_Choice
class for wrapping ly_set.
classes for wrapping lys_submodule.
uint8_t extensions_size()
LY_STMT_CARD cardinality()
uint8_t padding_iffsize()
uint8_t has_union_leafref()
std::vector< S_Ext_Instance > ext()
std::vector< std::string > expr()
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.
struct lys_ext_instance ** ext
LY_STMT_CARD
Possible cardinalities of the YANG statements.
LY_STMT
List of YANG statements.
Description of the extension instance substatement.
YANG extension definition.
Generic extension instance structure.
uint8_t has_union_leafref
LY_DATA_TYPE
YANG built-in types.
lyxp_node_type
Types of context nodes, LYXP_NODE_ROOT_CONFIG used only in when or must conditions.
LYS_OUTFORMAT
Schema output formats accepted by libyang printer functions.
enum lys_deviate_type LYS_DEVIATE_TYPE
Possible deviation modifications, see RFC 6020 sec. 7.18.3.2
enum lys_nodetype LYS_NODE
YANG schema node types.
YANG deviate statement structure, see RFC 6020 sec. 7.18.3.2
YANG deviation statement structure, see RFC 6020 sec. 7.18.3
YANG feature definition structure.
Structure to hold information about identity, see RFC 6020 sec. 7.16
Compiled if-feature expression structure.
YANG import structure used to reference other schemas (modules).
YANG include structure used to reference submodules.
Main schema node structure representing YANG module.
Common structure representing single YANG data statement describing.
YANG augment structure (covering both possibilities - uses's substatement as well as (sub)module's su...
Schema container node structure.
Schema grouping node structure.
RPC input and output node structure.
Schema leaf node structure.
Schema leaf-list node structure.
Schema list node structure.
Schema notification node structure.
Schema rpc/action node structure.
Schema uses node structure.
YANG uses's refine substatement structure, see RFC 6020 sec. 7.12.2
Container for list modifications in lys_refine_mod.
YANG validity restriction (must, length, etc.) structure providing information from the schema.
YANG revision statement for (sub)modules.
Submodule schema node structure that can be included into a YANG module.
YANG typedef structure providing information from the schema.
YANG type structure providing information from the schema.
Single bit value specification for lys_type_info_bits.
Single enumeration value specification for lys_type_info_enums.
Container for information about bits types (LY_TYPE_BINARY), used in lys_type_info.
Container for information about decimal64 types (LY_TYPE_DEC64), used in lys_type_info.
Container for information about enumeration types (LY_TYPE_ENUM), used in lys_type_info.
Container for information about identity types (LY_TYPE_IDENT), used in lys_type_info.
Container for information about instance-identifier types (LY_TYPE_INST), used in lys_type_info.
Container for information about leafref types (LY_TYPE_LEAFREF), used in lys_type_info.
Container for information about integer types, used in lys_type_info.
Container for information about string types (LY_TYPE_STRING), used in lys_type_info.
Container for information about union types (LY_TYPE_UNION), used in lys_type_info.
YANG list's unique statement structure, see RFC 6020 sec. 7.8.3
YANG when restriction, see RFC 6020 sec. 7.19.5
Union to hold target modification in lys_refine.
Union for holding type-specific information in lys_type.
The main libyang public header.
libyang representation of data model trees.