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 howtoxpath) 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...
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.
libyang representation of data trees.
libyang representation of data model trees.
#define LY_TREE_DFS_END(START, NEXT, ELEM)