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;};
133 const
char *
name() {
return submodule->name;};
137 const char *
dsc() {
return submodule->
dsc;};
139 const char *
ref() {
return submodule->
ref;};
141 const char *
org() {
return submodule->
org;};
211 const char *
dsc() {
return info_bit->
dsc;};
213 const char *
ref() {
return info_bit->
ref;};
223 std::vector<S_Ext_Instance> ext();
225 std::vector<S_Iffeature> iffeature();
239 std::vector<S_Type_Bit> bit();
275 const char *
dsc() {
return info_enum->
dsc;};
277 const char *
ref() {
return info_enum->
ref;};
287 std::vector<S_Ext_Instance> ext();
289 std::vector<S_Iffeature> iffeature();
303 std::vector<S_Type_Enum> enm();
319 std::vector<S_Ident>
ref();
365 S_Schema_Node_Leaf target();
399 std::vector<S_Type> types();
417 S_Type_Info_Binary binary();
419 S_Type_Info_Bits bits();
421 S_Type_Info_Dec64 dec64();
423 S_Type_Info_Enums enums();
425 S_Type_Info_Ident ident();
427 S_Type_Info_Inst inst();
429 S_Type_Info_Num num();
431 S_Type_Info_Lref lref();
433 S_Type_Info_Str str();
435 S_Type_Info_Union uni();
455 std::vector<S_Ext_Instance> ext();
478 std::vector<S_Ext_Instance> ext();
509 std::vector<S_Ext_Instance> ext();
511 S_Ext
def() LY_NEW(ext_instance, def,
Ext);
513 void *priv() {
return ext_instance->priv;};
517 LYS_NODE nodetype() {
return ext_instance->nodetype;};
542 std::vector<S_Ext_Instance> ext();
550 virtual S_Schema_Node parent();
552 virtual S_Schema_Node child();
554 virtual S_Schema_Node next();
556 virtual S_Schema_Node prev();
559 std::string path(
int options = 0);
563 std::vector<S_Schema_Node> child_instantiables(
int options);
565 S_Set find_path(
const char *path);
567 S_Set xpath_atomize(
enum lyxp_node_type ctx_node_type,
const char *expr,
int options);
569 S_Set xpath_atomize(
int options);
574 std::vector<S_Schema_Node> tree_for();
576 std::vector<S_Schema_Node> tree_dfs();
611 deleter(derived->deleter)
614 throw std::invalid_argument(
"Type must be LYS_CONTAINER");
644 deleter(derived->deleter)
647 throw std::invalid_argument(
"Type must be LYS_CHOICE");
660 S_Schema_Node dflt();
673 deleter(derived->deleter)
675 if (derived->node->nodetype !=
LYS_LEAF) {
676 throw std::invalid_argument(
"Type must be LYS_LEAF");
696 S_Schema_Node
child()
override {
return nullptr;};
698 S_Schema_Node_List is_key();
711 deleter(derived->deleter)
714 throw std::invalid_argument(
"Type must be LYS_LEAFLIST");
733 std::vector<S_Restr> must();
739 std::vector<std::string> dflt();
744 S_Schema_Node
child()
override {
return nullptr;};
757 deleter(derived->deleter)
759 if (derived->node->nodetype !=
LYS_LIST) {
760 throw std::invalid_argument(
"Type must be LYS_LIST");
781 std::vector<S_Restr> must();
783 std::vector<S_Tpdf> tpdf();
785 std::vector<S_Schema_Node_Leaf> keys();
787 std::vector<S_Unique> unique();
806 deleter(derived->deleter)
809 throw std::invalid_argument(
"Type must be LYS_ANYDATA or LYS_ANYXML");
824 std::vector<S_Restr> must();
837 deleter(derived->deleter)
839 if (derived->node->nodetype !=
LYS_USES) {
840 throw std::invalid_argument(
"Type must be LYS_USES");
855 std::vector<S_Refine> refine();
857 std::vector<S_Schema_Node_Augment> augment();
859 S_Schema_Node_Grp grp();
872 deleter(derived->deleter)
875 throw std::invalid_argument(
"Type must be LYS_GROUPING");
888 std::vector<S_Tpdf> tpdf();
901 deleter(derived->deleter)
903 if (derived->node->nodetype !=
LYS_CASE) {
904 throw std::invalid_argument(
"Type must be LYS_CASE");
928 deleter(derived->deleter)
931 throw std::invalid_argument(
"Type must be LYS_INOUT or LYS_OUTPUT");
946 std::vector<S_Tpdf> tpdf();
948 std::vector<S_Restr> must();
961 deleter(derived->deleter)
963 if (derived->node->nodetype !=
LYS_NOTIF) {
964 throw std::invalid_argument(
"Type must be LYS_NOTIF");
979 std::vector<S_Tpdf> tpdf();
981 std::vector<S_Restr> must();
994 deleter(derived->deleter)
996 if (derived->node->nodetype !=
LYS_ACTION && derived->node->nodetype !=
LYS_RPC) {
997 throw std::invalid_argument(
"Type must be LYS_ACTION or LYS_RPC");
1010 std::vector<S_Tpdf> tpdf();
1022 node(derived->node),
1023 deleter(derived->deleter)
1026 throw std::invalid_argument(
"Type must be LYS_AUGMENT");
1080 std::vector<S_Ext_Instance> ext_instance();
1116 S_Refine_Mod_List list();
1120 uint16_t target_type;
1149 std::vector<S_Ext_Instance> ext();
1155 std::vector<S_Restr> must();
1157 std::vector<std::
string> dflt() LY_NEW_STRING_LIST(refine, dflt, dflt_size);
1201 std::vector<std::string>
dflt() LY_NEW_STRING_LIST(deviate, dflt, dflt_size);
1203 std::vector<S_Ext_Instance> ext();
1223 S_Schema_Node orig_node();
1229 std::vector<S_Deviate> deviate();
1231 std::vector<S_Ext_Instance> ext();
1247 const
char *
prefix() {
return import->prefix;};
1249 char *
rev() {
return &
import->rev[0];};
1255 const
char *
dsc() {
return import->dsc;};
1257 const char *
ref() {
return import->ref;};
1273 char *
rev() {
return &include->rev[0];};
1279 const
char *
dsc() {
return include->dsc;};
1331 const
char *units() {
return tpdf->units;};
1337 const
char *dflt() {
return tpdf->dflt;};
1351 std::vector<std::string>
expr() LY_NEW_STRING_LIST(unique, expr, expr_size);
1353 uint8_t expr_size() {
return unique->expr_size;};
1383 std::vector<S_Iffeature> iffeature() LY_NEW_LIST(feature, iffeature, iffeature_size,
Iffeature);
1385 S_Module module() LY_NEW(feature, module,
Module);
1387 S_Set depfeatures() LY_NEW(feature, depfeatures,
Set);
1424 When(
struct lys_when *when, S_Deleter deleter =
nullptr);
1433 std::vector<S_Ext_Instance> ext();
1465 std::vector<S_Iffeature> iffeature() LY_NEW_LIST(ident, iffeature, iffeature_size,
Iffeature);
1467 S_Module module() LY_NEW(ident, module,
Module);
1469 std::vector<S_Ident> base();
1471 S_Set der() LY_NEW(ident, der,
Set);
Common structure representing single YANG data statement describing.
Schema_Node_Leaflist(S_Schema_Node derived)
std::vector< S_Ext_Instance > ext()
LY_STMT_CARD
Possible cardinalities of the YANG statements.
Schema leaf node structure.
Schema grouping node structure.
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.
friend Schema_Node_Anydata
Module(struct lys_module *module, S_Deleter deleter)
friend Schema_Node_Container
std::vector< S_Iffeature > iffeature()
Schema_Node_Uses(struct lys_node *node, S_Deleter deleter)
const char * target_name()
YANG uses's refine substatement structure, see RFC 6020 sec. 7.12.2
Schema_Node_Rpc_Action(S_Schema_Node derived)
YANG import structure used to reference other schemas (modules).
std::vector< S_Schema_Node > data_instantiables(int options)
Container for list modifications in lys_refine_mod.
Container for information about string types (LY_TYPE_STRING), used in lys_type_info.
std::vector< std::string > expr()
std::vector< std::string > dflt()
libyang representation of data model trees.
classes for wrapping lys_submodule.
uint8_t extensions_size()
YANG typedef structure providing information from the schema.
std::vector< S_Ext_Instance > ext()
lyxp_node_type
Types of context nodes, LYXP_NODE_ROOT_CONFIG used only in when or must conditions.
friend Schema_Node_Augment
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.
Schema_Node_Rpc_Action(struct lys_node *node, S_Deleter deleter)
Union for holding type-specific information in lys_type.
int validate_value(const char *value)
Container for information about leafref types (LY_TYPE_LEAFREF), used in lys_type_info.
class for wrapping ly_ctx.
Schema_Node_Anydata(S_Schema_Node derived)
Compiled if-feature expression structure.
Schema_Node_Grp(S_Schema_Node derived)
uint8_t insubstmt_index()
S_Schema_Node child() override
std::vector< S_Ext_Instance > ext()
Schema leaf-list node structure.
Schema_Node_List(S_Schema_Node derived)
YANG augment structure (covering both possibilities - uses's substatement as well as (sub)module's su...
LYS_OUTFORMAT
Schema output formats accepted by libyang printer functions.
uint8_t has_union_leafref()
Container for information about enumeration types (LY_TYPE_ENUM), used in lys_type_info.
Container for information about integer types, used in lys_type_info.
The main libyang public header.
std::vector< S_Ext_Instance > ext()
Union to hold target modification in lys_refine.
Container for information about decimal64 types (LY_TYPE_DEC64), used in lys_type_info.
struct lys_ext_instance ** ext
uint8_t has_union_leafref
std::vector< S_Ext_Instance > ext()
Schema_Node_Leaflist(struct lys_node *node, S_Deleter deleter)
std::vector< S_Deviation > deviation()
Schema_Node_Choice(S_Schema_Node derived)
int feature_enable(const char *feature)
Schema_Node_Choice(struct lys_node *node, S_Deleter deleter)
Container for information about identity types (LY_TYPE_IDENT), used in lys_type_info.
uint8_t padding_iffsize()
YANG when restriction, see RFC 6020 sec. 7.19.5
Container for information about bits types (LY_TYPE_BINARY), used in lys_type_info.
friend Schema_Node_Action
Schema_Node_List(struct lys_node *node, S_Deleter deleter)
classes for wrapping lyd_node.
Schema list node structure.
LY_STMT_CARD cardinality()
friend Schema_Node_Choice
Container for information about instance-identifier types (LY_TYPE_INST), used in lys_type_info.
Main schema node structure representing YANG module.
S_Schema_Node child() override
uint8_t devaiation_size()
Schema_Node_Augment(struct lys_node *node, S_Deleter deleter)
Schema_Node_Grp(struct lys_node *node, S_Deleter deleter)
Class implementation for libyang C header libyang.h.
RPC input and output node structure.
LY_DATA_TYPE
YANG built-in types.
Schema_Node_Leaf(struct lys_node *node, S_Deleter deleter)
std::string print_mem(LYS_OUTFORMAT format, int options)
YANG type structure providing information from the schema.
YANG list's unique statement structure, see RFC 6020 sec. 7.8.3
struct lys_node * swig_node()
Structure to hold information about identity, see RFC 6020 sec. 7.16
Schema_Node_Augment(S_Schema_Node derived)
Description of the extension instance substatement.
Schema_Node_Container(S_Schema_Node derived)
uint8_t extensions_size()
YANG deviate statement structure, see RFC 6020 sec. 7.18.3.2
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.
Schema uses node structure.
int feature_state(const char *feature)
Schema_Node_Notif(S_Schema_Node derived)
Schema notification node structure.
Schema_Node_Leaf(S_Schema_Node derived)
LY_STMT
List of YANG statements.
YANG validity restriction (must, length, etc.) structure providing information from the schema.
class for wrapping ly_set.
Schema_Node_Inout(S_Schema_Node derived)
enum lys_deviate_type LYS_DEVIATE_TYPE
Possible deviation modifications, see RFC 6020 sec. 7.18.3.2
Schema rpc/action node structure.
Generic extension instance structure.
Container for information about union types (LY_TYPE_UNION), used in lys_type_info.
Schema_Node_Notif(struct lys_node *node, S_Deleter deleter)
YANG extension definition.
YANG revision statement for (sub)modules.
YANG include structure used to reference submodules.
YANG feature definition structure.
friend Schema_Node_Leaflist
enum lys_nodetype LYS_NODE
YANG schema node types.
int feature_disable(const char *feature)
Schema_Node_Uses(S_Schema_Node derived)
Single bit value specification for lys_type_info_bits.
classes for wrapping lys_module.
friend Schema_Node_Rpc_Action
Schema_Node_Anydata(struct lys_node *node, S_Deleter deleter)
Schema_Node_Case(struct lys_node *node, S_Deleter deleter)
Schema container node structure.
YANG deviation statement structure, see RFC 6020 sec. 7.18.3