35 value_type(*value_type),
36 value_flags(value_flags),
46 auto bitDefinitions = type;
47 while (bitDefinitions->info.bits.count == 0) {
48 bitDefinitions = &type->
der->
type;
50 std::vector<S_Type_Bit> vec(bitDefinitions->info.bits.count);
52 for (
unsigned int i = 0; i < bitDefinitions->info.bits.count; ++i) {
54 vec[i] = std::make_shared<Type_Bit>(value.
bit[i], deleter);
64 return value.
instance ? std::make_shared<Data_Node>(value.
instance, deleter) :
nullptr;
70 return value.
leafref ? std::make_shared<Data_Node>(value.
leafref, deleter) :
nullptr;
81 throw std::invalid_argument(
"At least one of module or parent parameters must be set");
86 check_libyang_error(module ? module->module->ctx :
parent->node->schema->module->ctx);
90 deleter = !
parent ? std::make_shared<Deleter>(node, module->deleter) :
parent->deleter;
96 throw std::invalid_argument(
"At least one of module or parent parameters must be set");
101 check_libyang_error(module ? module->module->ctx :
parent->node->schema->module->ctx);
105 deleter = !
parent ? std::make_shared<Deleter>(node, module->deleter) :
parent->deleter;
111 throw std::invalid_argument(
"At least one of module or parent parameters must be set");
116 check_libyang_error(module ? module->module->ctx :
parent->node->schema->module->ctx);
120 deleter = !
parent ? std::make_shared<Deleter>(node, module->deleter) :
parent->deleter;
126 throw std::invalid_argument(
"At least one of module or parent parameters must be set");
132 check_libyang_error(module ? module->module->ctx :
parent->node->schema->module->ctx);
136 deleter = !
parent ? std::make_shared<Deleter>(node, module->deleter) :
parent->deleter;
142 throw std::invalid_argument(
"At least one of module or parent parameters must be set");
148 check_libyang_error(module ? module->module->ctx :
parent->node->schema->module->ctx);
152 deleter = !
parent ? std::make_shared<Deleter>(node, module->deleter) :
parent->deleter;
158 throw std::invalid_argument(
"Context can not be empty");
161 throw std::invalid_argument(
"Path can not be empty");
164 new_node =
lyd_new_path(NULL, context->ctx,
path, (
void *) value, value_type, options);
166 check_libyang_error(context->ctx);
170 deleter = std::make_shared<Deleter>(node, context->deleter);
176 throw std::invalid_argument(
"Context can not be empty");
179 throw std::invalid_argument(
"Path can not be empty");
184 check_libyang_error(context->ctx);
188 deleter = context->deleter;
194 throw std::invalid_argument(
"Context can not be empty");
197 throw std::invalid_argument(
"Path can not be empty");
202 check_libyang_error(context->ctx);
206 deleter = context->deleter;
212 char *path =
nullptr;
216 check_libyang_error(node->schema->module->ctx);
220 std::string s_path = path;
225 struct lyd_node *new_node =
nullptr;
227 new_node =
lyd_dup(node, recursive);
232 S_Deleter new_deleter = std::make_shared<Deleter>(new_node, deleter);
233 return std::make_shared<Data_Node>(new_node, new_deleter);
236 struct lyd_node *new_node =
nullptr;
243 S_Deleter new_deleter = std::make_shared<Deleter>(new_node, deleter);
244 return std::make_shared<Data_Node>(new_node, new_deleter);
247 struct lyd_node *new_node =
nullptr;
250 throw std::invalid_argument(
"Context can not be empty");
255 S_Deleter new_deleter = std::make_shared<Deleter>(new_node, context->deleter);
256 return new_node ? std::make_shared<Data_Node>(new_node, new_deleter) :
nullptr;
262 throw std::invalid_argument(
"Source can not be empty");
265 ret =
lyd_merge(node, source->node, options);
267 check_libyang_error(source->node->schema->module->ctx);
275 throw std::invalid_argument(
"Source can not be empty");
278 ret =
lyd_merge_to_ctx(&node, source->node, options, context ? context->ctx : NULL);
280 check_libyang_error(source->node->schema->module->ctx);
288 throw std::invalid_argument(
"New_node can not be empty");
301 throw std::invalid_argument(
"New_node can not be empty");
305 dup_node =
lyd_dup(new_node->node, 1);
320 throw std::invalid_argument(
"New_node can not be empty");
324 dup_node =
lyd_dup(new_node->node, 1);
339 throw std::invalid_argument(
"New_node can not be empty");
343 dup_node =
lyd_dup(new_node->node, 1);
367 return std::make_shared<Set>(
set, std::make_shared<Deleter>(
set, deleter));
372 throw std::invalid_argument(
"Schema can not be empty");
380 return std::make_shared<Set>(
set, std::make_shared<Deleter>(
set, deleter));
383 struct lyd_node *new_node =
nullptr;
387 return new_node ? std::make_shared<Data_Node>(new_node, deleter) :
nullptr;
400 throw std::invalid_argument(
"var_arg must be a data node");
403 ret =
lyd_validate(&node, options, (
void *) var_arg->node);
412 if (ret != EXIT_SUCCESS) {
421 throw std::invalid_argument(
"Second can not be empty");
429 return diff ? std::make_shared<Difflist>(
diff, deleter) :
nullptr;
432 struct lyd_node *new_node =
nullptr;
434 new_node =
lyd_new_path(node, ctx ? ctx->ctx : NULL,
path, (
void *)value, value_type, options);
439 return new_node ? std::make_shared<Data_Node>(new_node, deleter) :
nullptr;
442 struct lyd_node *new_node =
nullptr;
445 throw std::invalid_argument(
"Value can not be empty");
453 return new_node ? std::make_shared<Data_Node>(new_node, deleter) :
nullptr;
456 struct lyd_node *new_node =
nullptr;
459 throw std::invalid_argument(
"Value can not be empty");
467 return new_node ? std::make_shared<Data_Node>(new_node, deleter) :
nullptr;
484 deleter = std::make_shared<Deleter>(node,
nullptr);
497 return attr ? std::make_shared<Attr>(
attr, deleter) :
nullptr;
507 return module ? std::make_shared<Module>(module, deleter) :
nullptr;
510 char *strp =
nullptr;
519 std::string s_strp = strp;
525 std::vector<S_Data_Node> s_vector;
529 s_vector.push_back(std::make_shared<Data_Node>(elem, deleter));
535 std::vector<S_Data_Node> s_vector;
539 s_vector.push_back(std::make_shared<Data_Node>(elem, deleter));
547 Data_Node(derived->node, derived->deleter),
549 deleter(derived->deleter)
551 if (derived->node->schema->nodetype !=
LYS_LEAFLIST && derived->node->schema->nodetype !=
LYS_LEAF) {
552 throw std::invalid_argument(
"Type must be LYS_LEAFLIST or LYS_LEAF");
582 return std::make_shared<Type>((
struct lys_type *) type, deleter);
586 Data_Node(derived->node, derived->deleter),
588 deleter(derived->deleter)
590 if (derived->node->schema->nodetype !=
LYS_ANYDATA && derived->node->schema->nodetype !=
LYS_ANYXML) {
591 throw std::invalid_argument(
"Type must be LYS_ANYDATA or LYS_ANYXML");
615 deleter = std::make_shared<Deleter>(diff, deleter);
619 std::vector<S_Data_Node> s_vector;
626 for(i = 0; i <
sizeof(*diff->
first); i++) {
627 s_vector.push_back(std::make_shared<Data_Node>(*diff->
first, deleter));
633 std::vector<S_Data_Node> s_vector;
640 for(i = 0; i <
sizeof(*diff->
second); i++) {
641 s_vector.push_back(std::make_shared<Data_Node>(*diff->
second, deleter));
648 return new_node ? std::make_shared<Data_Node>(new_node,
nullptr) :
nullptr;
Class implementation for libyang C header libyang.h.
Class implementation for libyang C header tree_data.h.
Class implementation for libyang C header tree_schema.h.
Class implementation for libyang C header xml.h.
class for wrapping lyd_attr.
Attr(struct lyd_attr *attr, S_Deleter deleter=nullptr)
int change_leaf(const char *val_str)
classes for wrapping lyd_node.
S_Data_Node first_sibling()
std::string print_mem(LYD_FORMAT format, int options)
S_Attr insert_attr(S_Module module, const char *name, const char *value)
S_Set find_path(const char *expr)
int insert(S_Data_Node new_node)
Data_Node(struct lyd_node *node, S_Deleter deleter=nullptr)
std::vector< S_Data_Node > tree_for()
S_Data_Node new_path(S_Context ctx, const char *path, const char *value, LYD_ANYDATA_VALUETYPE value_type, int options)
int insert_after(S_Data_Node new_node)
friend Data_Node_Leaf_List
S_Data_Node dup_withsiblings(int recursive)
S_Data_Node dup(int recursive)
std::vector< S_Data_Node > tree_dfs()
int insert_sibling(S_Data_Node new_node)
int schema_sort(int recursive)
int merge_to_ctx(S_Data_Node source, int options, S_Context context)
int validate_value(const char *value)
int validate(int options, S_Context var_arg)
S_Set find_instance(S_Schema_Node schema)
S_Data_Node dup_to_ctx(int recursive, S_Context context)
int merge(S_Data_Node source, int options)
S_Difflist diff(S_Data_Node second, int options)
int insert_before(S_Data_Node new_node)
class for wrapping lyd_difflist.
std::vector< S_Data_Node > second()
std::vector< S_Data_Node > first()
Value(lyd_val value, LY_DATA_TYPE *value_type, uint8_t value_flags, struct lys_type *type, S_Deleter deleter)
std::vector< S_Type_Bit > bit()
S_Data_Node create_new_Data_Node(struct lyd_node *node)
struct lyd_node * leafref
struct lyd_node * instance
struct lys_ext_instance_complex * annotation
LY_DATA_TYPE _PACKED value_type
struct lys_type_bit ** bit
struct lyd_node ** second
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.
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)....
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.
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_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 lyd_insert_sibling(struct lyd_node **sibling, struct lyd_node *node)
Insert the node element as a last sibling of the specified sibling element.
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...
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.
int lyd_schema_sort(struct lyd_node *sibling, int recursive)
Order siblings according to the schema node ordering.
int lyd_print_mem(char **strp, const struct lyd_node *root, LYD_FORMAT format, int options)
Print data tree in the specified format.
int lyd_change_leaf(struct lyd_node_leaf_list *leaf, const char *val_str)
Change value of a leaf node.
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.
struct lys_module * lyd_node_module(const struct lyd_node *node)
Return main module of the data tree node.
struct lyd_difflist * lyd_diff(struct lyd_node *first, struct lyd_node *second, int options)
Compare two data trees and provide list of differences.
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.
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...
int lyd_validate(struct lyd_node **node, int options, void *var_arg,...)
Validate node data subtree.
LYD_FORMAT
Data input/output formats supported by libyang parser and printer functions.
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 lyd_node * lyd_first_sibling(struct lyd_node *node)
Get the first sibling of the given node.
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....
char * lyd_path(const struct lyd_node *node)
Build data path (usable as path, see XPath Addressing) of the data node.
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_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...
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...
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_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.
int lyd_merge(struct lyd_node *target, const struct lyd_node *source, int options)
Merge a (sub)tree into a data tree.
#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...
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.
int lyd_wd_default(struct lyd_node_leaf_list *node)
Get know if the node contain (despite implicit or explicit) default value.
#define LY_TREE_FOR(START, ELEM)
Macro to iterate via all sibling elements without affecting the list itself.
Structure for the result of lyd_diff(), describing differences between two data trees.
Generic structure for a data node, directly applicable to the data nodes defined as LYS_CONTAINER,...
Structure for data nodes defined as LYS_LEAF or LYS_LEAFLIST.
node's value representation
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...
Structure to hold a set of (not necessary somehow connected) lyd_node or lys_node objects....
struct lys_module * module
LY_DATA_TYPE _PACKED base
LY_DATA_TYPE
YANG built-in types.
Main schema node structure representing YANG module.
YANG type structure providing information from the schema.
The main libyang public header.
libyang representation of data trees.
libyang representation of data model trees.
#define LY_TREE_DFS_END(START, NEXT, ELEM)