35 value_type(*value_type),
36 value_flags(value_flags),
49 vec[i] = std::make_shared<Type_Bit>(value.
bit[i], deleter);
59 return value.
instance ? std::make_shared<Data_Node>(value.
instance, deleter) :
nullptr;
65 return value.
leafref ? std::make_shared<Data_Node>(value.
leafref, deleter) :
nullptr;
76 throw std::invalid_argument(
"At least one of module or parent parameters must be set");
81 check_libyang_error(module ? module->module->ctx :
parent->node->schema->module->ctx);
85 deleter = !
parent ? std::make_shared<Deleter>(node, module->deleter) :
parent->deleter;
91 throw std::invalid_argument(
"At least one of module or parent parameters must be set");
96 check_libyang_error(module ? module->module->ctx :
parent->node->schema->module->ctx);
100 deleter = !
parent ? std::make_shared<Deleter>(node, module->deleter) :
parent->deleter;
106 throw std::invalid_argument(
"At least one of module or parent parameters must be set");
111 check_libyang_error(module ? module->module->ctx :
parent->node->schema->module->ctx);
115 deleter = !
parent ? std::make_shared<Deleter>(node, module->deleter) :
parent->deleter;
121 throw std::invalid_argument(
"At least one of module or parent parameters must be set");
127 check_libyang_error(module ? module->module->ctx :
parent->node->schema->module->ctx);
131 deleter = !
parent ? std::make_shared<Deleter>(node, module->deleter) :
parent->deleter;
137 throw std::invalid_argument(
"At least one of module or parent parameters must be set");
143 check_libyang_error(module ? module->module->ctx :
parent->node->schema->module->ctx);
147 deleter = !
parent ? std::make_shared<Deleter>(node, module->deleter) :
parent->deleter;
153 throw std::invalid_argument(
"Context can not be empty");
156 throw std::invalid_argument(
"Path can not be empty");
159 new_node =
lyd_new_path(NULL, context->ctx,
path, (
void *) value, value_type, options);
161 check_libyang_error(context->ctx);
165 deleter = std::make_shared<Deleter>(node, context->deleter);
171 throw std::invalid_argument(
"Context can not be empty");
174 throw std::invalid_argument(
"Path can not be empty");
179 check_libyang_error(context->ctx);
183 deleter = context->deleter;
189 throw std::invalid_argument(
"Context can not be empty");
192 throw std::invalid_argument(
"Path can not be empty");
197 check_libyang_error(context->ctx);
201 deleter = context->deleter;
207 char *path =
nullptr;
211 check_libyang_error(node->schema->module->ctx);
215 std::string s_path = path;
220 struct lyd_node *new_node =
nullptr;
222 new_node =
lyd_dup(node, recursive);
227 S_Deleter new_deleter = std::make_shared<Deleter>(new_node, deleter);
228 return std::make_shared<Data_Node>(new_node, new_deleter);
231 struct lyd_node *new_node =
nullptr;
238 S_Deleter new_deleter = std::make_shared<Deleter>(new_node, deleter);
239 return std::make_shared<Data_Node>(new_node, new_deleter);
242 struct lyd_node *new_node =
nullptr;
245 throw std::invalid_argument(
"Context can not be empty");
250 S_Deleter new_deleter = std::make_shared<Deleter>(new_node, context->deleter);
251 return new_node ? std::make_shared<Data_Node>(new_node, new_deleter) :
nullptr;
257 throw std::invalid_argument(
"Source can not be empty");
260 ret =
lyd_merge(node, source->node, options);
262 check_libyang_error(source->node->schema->module->ctx);
270 throw std::invalid_argument(
"Source can not be empty");
273 ret =
lyd_merge_to_ctx(&node, source->node, options, context ? context->ctx : NULL);
275 check_libyang_error(source->node->schema->module->ctx);
283 throw std::invalid_argument(
"New_node can not be empty");
296 throw std::invalid_argument(
"New_node can not be empty");
300 dup_node =
lyd_dup(new_node->node, 1);
315 throw std::invalid_argument(
"New_node can not be empty");
319 dup_node =
lyd_dup(new_node->node, 1);
334 throw std::invalid_argument(
"New_node can not be empty");
338 dup_node =
lyd_dup(new_node->node, 1);
362 return std::make_shared<Set>(
set, std::make_shared<Deleter>(
set, deleter));
367 throw std::invalid_argument(
"Schema can not be empty");
375 return std::make_shared<Set>(
set, std::make_shared<Deleter>(
set, deleter));
378 struct lyd_node *new_node =
nullptr;
382 return new_node ? std::make_shared<Data_Node>(new_node, deleter) :
nullptr;
395 throw std::invalid_argument(
"var_arg must be a data node");
398 ret =
lyd_validate(&node, options, (
void *) var_arg->node);
407 if (ret != EXIT_SUCCESS) {
416 throw std::invalid_argument(
"Second can not be empty");
424 return diff ? std::make_shared<Difflist>(
diff, deleter) :
nullptr;
427 struct lyd_node *new_node =
nullptr;
429 new_node =
lyd_new_path(node, ctx ? ctx->ctx : NULL,
path, (
void *)value, value_type, options);
434 return new_node ? std::make_shared<Data_Node>(new_node, deleter) :
nullptr;
437 struct lyd_node *new_node =
nullptr;
440 throw std::invalid_argument(
"Value can not be empty");
448 return new_node ? std::make_shared<Data_Node>(new_node, deleter) :
nullptr;
451 struct lyd_node *new_node =
nullptr;
454 throw std::invalid_argument(
"Value can not be empty");
462 return new_node ? std::make_shared<Data_Node>(new_node, deleter) :
nullptr;
479 deleter = std::make_shared<Deleter>(node,
nullptr);
492 return attr ? std::make_shared<Attr>(
attr, deleter) :
nullptr;
502 return module ? std::make_shared<Module>(module, deleter) :
nullptr;
505 char *strp =
nullptr;
514 std::string s_strp = strp;
520 std::vector<S_Data_Node> s_vector;
524 s_vector.push_back(std::make_shared<Data_Node>(elem, deleter));
530 std::vector<S_Data_Node> s_vector;
534 s_vector.push_back(std::make_shared<Data_Node>(elem, deleter));
542 Data_Node(derived->node, derived->deleter),
544 deleter(derived->deleter)
546 if (derived->node->schema->nodetype !=
LYS_LEAFLIST && derived->node->schema->nodetype !=
LYS_LEAF) {
547 throw std::invalid_argument(
"Type must be LYS_LEAFLIST or LYS_LEAF");
577 return std::make_shared<Type>((
struct lys_type *) type, deleter);
581 Data_Node(derived->node, derived->deleter),
583 deleter(derived->deleter)
585 if (derived->node->schema->nodetype !=
LYS_ANYDATA && derived->node->schema->nodetype !=
LYS_ANYXML) {
586 throw std::invalid_argument(
"Type must be LYS_ANYDATA or LYS_ANYXML");
610 deleter = std::make_shared<Deleter>(diff, deleter);
614 std::vector<S_Data_Node> s_vector;
621 for(i = 0; i <
sizeof(*diff->
first); i++) {
622 s_vector.push_back(std::make_shared<Data_Node>(*diff->
first, deleter));
628 std::vector<S_Data_Node> s_vector;
635 for(i = 0; i <
sizeof(*diff->
second); i++) {
636 s_vector.push_back(std::make_shared<Data_Node>(*diff->
second, deleter));
643 return new_node ? std::make_shared<Data_Node>(new_node,
nullptr) :
nullptr;
int insert(S_Data_Node new_node)
int insert_before(S_Data_Node new_node)
struct lys_module * module
struct lyd_node * lyd_new_anydata(struct lyd_node *parent, const struct lys_module *module, const char *name, void *value, LYD_ANYDATA_VALUETYPE value_type)
Create a new anydata or anyxml node in a data tree.
int schema_sort(int recursive)
int change_leaf(const char *val_str)
struct lyd_node * lyd_dup_to_ctx(const struct lyd_node *node, int options, struct ly_ctx *ctx)
Create a copy of the specified data tree node in the different context. All the schema references and...
struct lys_type_info_bits bits
int merge_to_ctx(S_Data_Node source, int options, S_Context context)
int validate(int options, S_Context var_arg)
int lyd_validate(struct lyd_node **node, int options, void *var_arg,...)
Validate node data subtree.
char * lyd_path(const struct lyd_node *node)
Build data path (usable as path, see XPath Addressing) of the data node.
struct lyd_attr * lyd_insert_attr(struct lyd_node *parent, const struct lys_module *mod, const char *name, const char *value)
Insert attribute into the data node.
struct lys_ext_instance_complex * annotation
S_Data_Node create_new_Data_Node(struct lyd_node *node)
struct lys_module * lyd_node_module(const struct lyd_node *node)
Return main module of the data tree node.
Class implementation for libyang C header xml.h.
struct lyd_node * lyd_dup_withsiblings(const struct lyd_node *node, int options)
Create a copy of the specified data tree and all its siblings (preceding as well as following)...
S_Data_Node dup(int recursive)
node's value representation
S_Data_Node first_sibling()
libyang representation of data model trees.
int lyd_wd_default(struct lyd_node_leaf_list *node)
Get know if the node contain (despite implicit or explicit) default value.
int merge(S_Data_Node source, int options)
int lyd_insert(struct lyd_node *parent, struct lyd_node *node)
Insert the node element as child to the parent element. The node is inserted as a last child of the p...
Value(lyd_val value, LY_DATA_TYPE *value_type, uint8_t value_flags, struct lys_type *type, S_Deleter deleter)
LY_DATA_TYPE _PACKED value_type
struct lyd_node * lyd_dup(const struct lyd_node *node, int options)
Create a copy of the specified data tree node. Schema references are kept the same. Use carefully, since libyang silently creates default nodes, it is always better to use lyd_dup_withsiblings() to duplicate the complete data tree.
Data_Node_Anydata(S_Data_Node derived)
Data_Node(struct lyd_node *node, S_Deleter deleter=nullptr)
struct lyd_node * lyd_new_path(struct lyd_node *data_tree, const struct ly_ctx *ctx, const char *path, void *value, LYD_ANYDATA_VALUETYPE value_type, int options)
Create a new data node based on a simple XPath.
S_Set find_path(const char *expr)
libyang representation of data trees.
The main libyang public header.
Class implementation for libyang C header tree_schema.h.
LYD_FORMAT
Data input/output formats supported by libyang parser and printer functions.
std::vector< S_Data_Node > first()
struct lys_type_bit ** bit
Structure to hold a set of (not necessary somehow connected) lyd_node or lys_node objects...
struct lyd_difflist * lyd_diff(struct lyd_node *first, struct lyd_node *second, int options)
Compare two data trees and provide list of differences.
S_Attr insert_attr(S_Module module, const char *name, const char *value)
unsigned int lyd_list_pos(const struct lyd_node *node)
Learn the relative instance position of a list or leaf-list within other instances of the same schema...
int lyd_schema_sort(struct lyd_node *sibling, int recursive)
Order siblings according to the schema node ordering.
Attr(struct lyd_attr *attr, S_Deleter deleter=nullptr)
S_Data_Node dup_withsiblings(int recursive)
#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...
int lyd_insert_after(struct lyd_node *sibling, struct lyd_node *node)
Insert the node element after the sibling element. If node and siblings are already siblings (just mo...
std::vector< S_Data_Node > second()
S_Difflist diff(S_Data_Node second, int options)
Structure for data nodes defined as LYS_LEAF or LYS_LEAFLIST.
struct lyd_node * leafref
#define LY_TREE_DFS_END(START, NEXT, ELEM)
int lyd_insert_sibling(struct lyd_node **sibling, struct lyd_node *node)
Insert the node element as a last sibling of the specified sibling element.
struct lyd_node * lyd_new_leaf(struct lyd_node *parent, const struct lys_module *module, const char *name, const char *val_str)
Create a new leaf or leaflist node in a data tree with a string value that is converted to the actual...
classes for wrapping lyd_node.
class for wrapping lyd_difflist.
struct lyd_node ** second
int lyd_insert_before(struct lyd_node *sibling, struct lyd_node *node)
Insert the node element after the sibling element. If node and siblings are already siblings (just mo...
Structure for the result of lyd_diff(), describing differences between two data trees.
int validate_value(const char *value)
Main schema node structure representing YANG module.
Data_Node_Leaf_List(S_Data_Node derived)
int lyd_print_mem(char **strp, const struct lyd_node *root, LYD_FORMAT format, int options)
Print data tree in the specified format.
std::string print_mem(LYD_FORMAT format, int options)
#define LY_TREE_FOR(START, ELEM)
Macro to iterate via all sibling elements without affecting the list itself.
class for wrapping lyd_attr.
int insert_sibling(S_Data_Node new_node)
struct ly_set * lyd_find_instance(const struct lyd_node *data, const struct lys_node *schema)
Search in the given data for instances of the provided schema node.
struct lyd_node * lyd_first_sibling(struct lyd_node *node)
Get the first sibling of the given node.
Class implementation for libyang C header libyang.h.
LY_DATA_TYPE _PACKED base
LY_DATA_TYPE
YANG built-in types.
struct lyd_node * instance
std::vector< S_Data_Node > tree_dfs()
YANG type structure providing information from the schema.
struct ly_set * lyd_find_path(const struct lyd_node *ctx_node, const char *path)
Search in the given data for instances of nodes matching the provided path.
void * lys_ext_complex_get_substmt(LY_STMT stmt, struct lys_ext_instance_complex *ext, struct lyext_substmt **info)
get pointer to the place where the specified extension's substatement is supposed to be stored in the...
const struct lys_type * lyd_leaf_type(const struct lyd_node_leaf_list *leaf)
Get the type structure of a leaf.
struct lyd_node * lyd_new(struct lyd_node *parent, const struct lys_module *module, const char *name)
Create a new container node in a data tree.
S_Data_Node new_path(S_Context ctx, const char *path, const char *value, LYD_ANYDATA_VALUETYPE value_type, int options)
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...
Class implementation for libyang C header tree_data.h.
Generic structure for a data node, directly applicable to the data nodes defined as LYS_CONTAINER...
std::vector< S_Data_Node > tree_for()
std::vector< S_Type_Bit > bit()
LYD_ANYDATA_VALUETYPE
List of possible value types stored in lyd_node_anydata.
int lyd_unlink(struct lyd_node *node)
Unlink the specified data subtree. All referenced namespaces are copied.
int lyd_change_leaf(struct lyd_node_leaf_list *leaf, const char *val_str)
Change value of a leaf node.
int lyd_merge(struct lyd_node *target, const struct lyd_node *source, int options)
Merge a (sub)tree into a data tree.
int insert_after(S_Data_Node new_node)
int lyd_merge_to_ctx(struct lyd_node **trg, const struct lyd_node *src, int options, struct ly_ctx *ctx)
Same as lyd_merge(), but moves the resulting data into the specified context.
S_Data_Node dup_to_ctx(int recursive, S_Context context)
S_Set find_instance(S_Schema_Node schema)