tree_data.h

Go to the documentation of this file.

 
#ifndef LY_TREE_DATA_H_
#define LY_TREE_DATA_H_
 
/* socket/ip includes in ly_config.h */
 
#include <stddef.h>
#include <stdint.h>
#include <time.h>
 
#include "log.h"
#include "ly_config.h"
#include "tree.h"
#include "tree_schema.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
struct ly_ctx;
struct ly_path;
struct ly_set;
struct lyd_node;
struct lyd_node_opaq;
struct lyd_node_term;
struct timespec;
struct lyxp_var;
struct rb_node;





 
/* *INDENT-OFF* */

#define LYD_TREE_DFS_BEGIN(START, ELEM) \
    { ly_bool LYD_TREE_DFS_continue = 0; struct lyd_node *LYD_TREE_DFS_next; \
    for ((ELEM) = (LYD_TREE_DFS_next) = (struct lyd_node *)(START); \
         (ELEM); \
         (ELEM) = (LYD_TREE_DFS_next), LYD_TREE_DFS_continue = 0)

#define _LYD_TREE_DFS_END(START, ELEM, FUNC) \
    /* select element for the next run - children first */ \
    if (LYD_TREE_DFS_continue) { \
        (LYD_TREE_DFS_next) = NULL; \
    } else { \
        (LYD_TREE_DFS_next) = FUNC(ELEM); \
    }\
    if (!(LYD_TREE_DFS_next)) { \
        /* no children */ \
        if ((ELEM) == (struct lyd_node *)(START)) { \
            /* we are done, (START) has no children */ \
            break; \
        } \
        /* try siblings */ \
        (LYD_TREE_DFS_next) = (ELEM)->next; \
    } \
    while (!(LYD_TREE_DFS_next)) { \
        /* parent is already processed, go to its sibling */ \
        (ELEM) = (struct lyd_node *)(ELEM)->parent; \
        /* no siblings, go back through parents */ \
        if ((ELEM)->parent == (START)->parent) { \
            /* we are done, no next element to process */ \
            break; \
        } \
        (LYD_TREE_DFS_next) = (ELEM)->next; \
    } }

#define LYD_TREE_DFS_END(START, ELEM) \
    _LYD_TREE_DFS_END(START, ELEM, lyd_child)

#define LYD_TREE_ANY_DFS_END(START, ELEM) \
    _LYD_TREE_DFS_END(START, ELEM, lyd_child_any)

#define LYD_LIST_FOR_INST(START, SCHEMA, ELEM) \
    for (lyd_find_sibling_val(START, SCHEMA, NULL, 0, &(ELEM)); \
         (ELEM) && ((ELEM)->schema == (SCHEMA)); \
         (ELEM) = (ELEM)->next)

#define LYD_LIST_FOR_INST_SAFE(START, SCHEMA, NEXT, ELEM) \
    for ((NEXT) = (ELEM) = NULL, lyd_find_sibling_val(START, SCHEMA, NULL, 0, &(ELEM)); \
         (ELEM) && ((ELEM)->schema == (SCHEMA)) ? ((NEXT) = (ELEM)->next, 1) : 0; \
         (ELEM) = (NEXT))
 
/* *INDENT-ON* */

#define LYD_CTX(node) ((node)->schema ? (node)->schema->module->ctx : ((const struct lyd_node_opaq *)(node))->ctx)

#define LYD_NODE_IS_ALONE(NODE) \
    (((NODE)->prev == NODE) || \
        (((NODE)->prev->schema != (NODE)->schema) && (!(NODE)->next || ((NODE)->schema != (NODE)->next->schema))))

typedef enum {
    LYD_UNKNOWN = 0,     
    LYD_XML,             
    LYD_JSON,            
    LYD_LYB              
} LYD_FORMAT;


struct lyd_value {
    const char *_canonical;          
    const struct lysc_type *realtype; 
 
    union {
        int8_t boolean;              
        int64_t dec64;               
        int8_t int8;                 
        int16_t int16;               
        int32_t int32;               
        int64_t int64;               
        uint8_t uint8;               
        uint16_t uint16;             
        uint32_t uint32;             
        uint64_t uint64;             
        struct lysc_type_bitenum_item *enum_item;  
        struct lysc_ident *ident;    
        struct ly_path *target;      
        struct lyd_value_union *subvalue; 
 
        void *dyn_mem;               
        uint8_t fixed_mem[LYD_VALUE_FIXED_MEM_SIZE]; 
    };  

};

#define LYD_VALUE_GET(value, type_val) \
    ((sizeof *(type_val) > LYD_VALUE_FIXED_MEM_SIZE) \
     ? ((type_val) = (((value)->dyn_mem))) \
     : ((type_val) = ((void *)((value)->fixed_mem))))

struct lyd_value_union {
    struct lyd_value value;      
    void *original;              
    uint64_t orig_size_bits;     
    uint32_t hints;              
    LY_VALUE_FORMAT format;      
    void *prefix_data;           
    const struct lysc_node *ctx_node;           
};

struct lyd_value_bits {
    char *bitmap;                           
    struct lysc_type_bitenum_item **items;  
};

struct lyd_value_binary {
    void *data;     
    uint32_t size;  
};

struct lyd_value_ipv4_address_no_zone {
    struct in_addr addr;    
};

struct lyd_value_ipv4_address {
    struct in_addr addr;    
    const char *zone;       
};

struct lyd_value_ipv4_prefix {
    struct in_addr addr;    
    uint8_t prefix;         
};

struct lyd_value_ipv6_address_no_zone {
    struct in6_addr addr;   
};

struct lyd_value_ipv6_address {
    struct in6_addr addr;   
    const char *zone;       
};

struct lyd_value_ipv6_prefix {
    struct in6_addr addr;   
    uint8_t prefix;         
};

struct lyd_value_date_and_time {
    time_t time;        
    char *fractions_s;  
    ly_bool unknown_tz; 
};

struct lyd_value_date {
    time_t time;        
    ly_bool unknown_tz; 
};

struct lyd_value_date_nz {
    time_t time;        
};

struct lyd_value_time {
    uint32_t seconds;   
    char *fractions_s;  
    ly_bool unknown_tz; 
};

struct lyd_value_time_nz {
    uint32_t seconds;   
    char *fractions_s;  
};

struct lyd_value_xpath10 {
    struct lyxp_expr *exp;
    const struct ly_ctx *ctx;
    void *prefix_data;
    LY_VALUE_FORMAT format;
};

struct lyd_value_lyds_tree {
    struct rb_node *rbt;        
};

struct ly_opaq_name {
    const char *name;             
    const char *prefix;           
 
    union {
        const char *module_ns;    
        const char *module_name;  
    };
};

struct lyd_attr {
    struct lyd_node_opaq *parent;   
    struct lyd_attr *next;          
    struct ly_opaq_name name;       
    const char *value;              
    uint32_t hints;                 
    LY_VALUE_FORMAT format;         
    void *val_prefix_data;          
};
 
#define LYD_NODE_INNER (LYS_CONTAINER|LYS_LIST|LYS_RPC|LYS_ACTION|LYS_NOTIF) 
#define LYD_NODE_TERM (LYS_LEAF|LYS_LEAFLIST)   
#define LYD_NODE_ANY (LYS_ANYDATA)   

 
#define LYD_DEFAULT     0x01        
#define LYD_WHEN_TRUE   0x02        
#define LYD_NEW         0x04        
#define LYD_EXT         0x08        
#define LYD_WHEN_FALSE  0x10        


struct lyd_node {
    uint32_t hash;                   
    uint32_t flags;                  
    const struct lysc_node *schema;  
    struct lyd_node *parent;         
    struct lyd_node *next;           
    struct lyd_node *prev;           
    struct lyd_meta *meta;           
    void *priv;                      
};

struct lyd_node_inner {
    union {
        struct lyd_node node;               
 
        struct {
            uint32_t hash;                  
            uint32_t flags;                 
            const struct lysc_node *schema; 
            struct lyd_node *parent;        
            struct lyd_node *next;          
            struct lyd_node *prev;          
            struct lyd_meta *meta;          
            void *priv;                     
        };
    };                                      
 
    struct lyd_node *child;          
    struct ly_ht *children_ht;  
 
#define LYD_HT_MIN_ITEMS 4           
};

struct lyd_node_term {
    union {
        struct lyd_node node;               
 
        struct {
            uint32_t hash;                  
            uint32_t flags;                 
            const struct lysc_node *schema; 
            struct lyd_node *parent;        
            struct lyd_node *next;          
            struct lyd_node *prev;          
            struct lyd_meta *meta;          
            void *priv;                     
        };
    };                                      
 
    struct lyd_value value;          
};

struct lyd_node_any {
    union {
        struct lyd_node node;               
 
        struct {
            uint32_t hash;                  
            uint32_t flags;                 
            const struct lysc_node *schema; 
            struct lyd_node *parent;        
            struct lyd_node *next;          
            struct lyd_node *prev;          
            struct lyd_meta *meta;          
            void *priv;                     
        };
    };                                      
 
    struct lyd_node *child;             
    struct ly_ht *children_ht;          
    const char *value;                  
    uint32_t hints;                     
};

#define LYD_NAME(node) ((node)->schema ? (node)->schema->name : ((struct lyd_node_opaq *)node)->name.name)

#define LYD_VALHINT_STRING     0x0001 
#define LYD_VALHINT_DECNUM     0x0002 
#define LYD_VALHINT_OCTNUM     0x0004 
#define LYD_VALHINT_HEXNUM     0x0008 
#define LYD_VALHINT_NUM64      0x0010 
#define LYD_VALHINT_BOOLEAN    0x0020 
#define LYD_VALHINT_EMPTY      0x0040 
#define LYD_VALHINT_STRING_DATATYPES 0x0080 

#define LYD_NODEHINT_LIST       0x1000 
#define LYD_NODEHINT_LEAFLIST   0x2000 
#define LYD_NODEHINT_CONTAINER  0x4000 

#define LYD_HINT_DATA       0xFFF3 
#define LYD_HINT_SCHEMA     0xFFFF 

struct lyd_node_opaq {
    union {
        struct lyd_node node;               
 
        struct {
            uint32_t hash;                  
            uint32_t flags;                 
            const struct lysc_node *schema; 
            struct lyd_node *parent;        
            struct lyd_node *next;          
            struct lyd_node *prev;          
            struct lyd_meta *meta;          
            void *priv;                     
        };
    };                                      
 
    struct lyd_node *child;         
 
    struct ly_opaq_name name;       
    const char *value;              
    uint32_t hints;                 
    LY_VALUE_FORMAT format;         
    void *val_prefix_data;          
 
    struct lyd_attr *attr;          
    const struct ly_ctx *ctx;       
};

struct lyd_leafref_links_rec {
    const struct lyd_node_term *node;           
    const struct lyd_node_term **leafref_nodes; 
    const struct lyd_node_term **target_nodes;  
};

#define lyd_parent(node) ((node) ? (node)->parent : NULL)

static inline struct lyd_node *
lyd_child(const struct lyd_node *node)
{
    if (!node) {
        return NULL;
    }
 
    if (!node->schema) {
        /* opaq node */
        return ((const struct lyd_node_opaq *)node)->child;
    }
 
    if (node->schema->nodetype & (LYS_CONTAINER | LYS_LIST | LYS_RPC | LYS_ACTION | LYS_NOTIF)) {
        return ((const struct lyd_node_inner *)node)->child;
    }
 
    return NULL;
}

static inline struct lyd_node *
lyd_child_any(const struct lyd_node *node)
{
    if (!node) {
        return NULL;
    }
 
    if (!node->schema) {
        /* opaq node */
        return ((const struct lyd_node_opaq *)node)->child;
    }
 
    if (node->schema->nodetype & (LYS_CONTAINER | LYS_LIST | LYS_RPC | LYS_ACTION | LYS_NOTIF | LYS_ANYDATA)) {
        return ((const struct lyd_node_inner *)node)->child;
    }
 
    return NULL;
}

LIBYANG_API_DECL struct lyd_node *lyd_child_no_keys(const struct lyd_node *node);

LIBYANG_API_DECL const struct lys_module *lyd_owner_module(const struct lyd_node *node);

LIBYANG_API_DECL const struct lys_module *lyd_node_module(const struct lyd_node *node);

LIBYANG_API_DECL ly_bool lyd_is_default(const struct lyd_node *node);

LIBYANG_API_DECL uint32_t lyd_list_pos(const struct lyd_node *instance);

LIBYANG_API_DECL struct lyd_node *lyd_first_sibling(const struct lyd_node *node);

LIBYANG_API_DECL LY_ERR lyd_parse_opaq_error(const struct lyd_node *node);

LIBYANG_API_DECL const char *lyd_value_get_canonical(const struct ly_ctx *ctx, const struct lyd_value *value);

static inline const char *
lyd_get_value(const struct lyd_node *node)
{
    if (!node) {
        return NULL;
    }
 
    if (!node->schema) {
        return ((const struct lyd_node_opaq *)node)->value;
    } else if (node->schema->nodetype & LYD_NODE_TERM) {
        const struct lyd_value *value = &((const struct lyd_node_term *)node)->value;
 
        return value->_canonical ? value->_canonical : lyd_value_get_canonical(LYD_CTX(node), value);
    }
 
    return NULL;
}

LIBYANG_API_DECL LY_ERR lyd_any_value_str(const struct lyd_node *any, LYD_FORMAT format, char **value_str);

LIBYANG_API_DECL LY_ERR lyd_any_copy_value(struct lyd_node *trg, const struct lyd_node *child, const char *value,
        uint32_t hints);

LIBYANG_API_DECL const struct lysc_node *lyd_node_schema(const struct lyd_node *node);

LIBYANG_API_DECL ly_bool lyd_meta_is_internal(const struct lyd_meta *meta);

LIBYANG_API_DECL LY_ERR lyd_new_inner(struct lyd_node *parent, const struct lys_module *module, const char *name,
        ly_bool output, struct lyd_node **node);

 
#define LYD_NEW_VAL_OUTPUT 0x01      
#define LYD_NEW_VAL_STORE_ONLY 0x02  
#define LYD_NEW_VAL_CANON 0x04       
#define LYD_NEW_META_CLEAR_DFLT 0x08 
#define LYD_NEW_PATH_UPDATE 0x10     
#define LYD_NEW_PATH_OPAQ 0x20       
#define LYD_NEW_PATH_WITH_OPAQ 0x40  
#define LYD_NEW_PATH_ANY_DATATREE 0x80  
#define LYD_NEW_ANY_USE_VALUE 0x0100    


LIBYANG_API_DECL LY_ERR lyd_new_list(struct lyd_node *parent, const struct lys_module *module, const char *name,
        uint32_t options, struct lyd_node **node, ...);

LIBYANG_API_DECL LY_ERR lyd_new_list2(struct lyd_node *parent, const struct lys_module *module, const char *name,
        const char *keys, uint32_t options, struct lyd_node **node);

LIBYANG_API_DECL LY_ERR lyd_new_list3(struct lyd_node *parent, const struct lys_module *module, const char *name,
        const void **key_values, uint32_t *value_sizes_bits, uint32_t options, struct lyd_node **node);

LIBYANG_API_DECL LY_ERR lyd_new_term(struct lyd_node *parent, const struct lys_module *module, const char *name,
        const char *value, uint32_t options, struct lyd_node **node);

LIBYANG_API_DECL LY_ERR lyd_new_term_raw(struct lyd_node *parent, const struct lys_module *module, const char *name,
        const void *value_ptr, uint32_t value_size, uint32_t options, struct lyd_node **node);

LIBYANG_API_DECL LY_ERR lyd_new_any(struct lyd_node *parent, const struct lys_module *module, const char *name,
        const struct lyd_node *child, const char *value, uint32_t hints, uint32_t options, struct lyd_node **node);

LIBYANG_API_DECL LY_ERR lyd_new_meta(const struct ly_ctx *ctx, struct lyd_node *parent, const struct lys_module *module,
        const char *name, const char *val_str, uint32_t options, struct lyd_meta **meta);

LIBYANG_API_DECL LY_ERR lyd_new_meta2(const struct ly_ctx *ctx, struct lyd_node *parent, uint32_t options,
        const struct lyd_attr *attr, struct lyd_meta **meta);

LIBYANG_API_DECL LY_ERR lyd_new_opaq(struct lyd_node *parent, const struct ly_ctx *ctx, const char *name, const char *value,
        const char *prefix, const char *module_name, struct lyd_node **node);

LIBYANG_API_DECL LY_ERR lyd_new_opaq2(struct lyd_node *parent, const struct ly_ctx *ctx, const char *name, const char *value,
        const char *prefix, const char *module_ns, struct lyd_node **node);

LIBYANG_API_DECL LY_ERR lyd_new_attr(struct lyd_node *parent, const char *module_name, const char *name, const char *value,
        struct lyd_attr **attr);

LIBYANG_API_DECL LY_ERR lyd_new_attr2(struct lyd_node *parent, const char *module_ns, const char *name, const char *value,
        struct lyd_attr **attr);

LIBYANG_API_DECL LY_ERR lyd_new_path(struct lyd_node *parent, const struct ly_ctx *ctx, const char *path, const char *value,
        uint32_t options, struct lyd_node **node);

LIBYANG_API_DECL LY_ERR lyd_new_path2(struct lyd_node *parent, const struct ly_ctx *ctx, const char *path,
        const void *value, uint64_t value_size_bits, uint32_t any_hints, uint32_t options, struct lyd_node **new_parent,
        struct lyd_node **new_node);

 
#define LYD_IMPLICIT_NO_STATE    0x01   
#define LYD_IMPLICIT_NO_CONFIG   0x02   
#define LYD_IMPLICIT_OUTPUT      0x04   
#define LYD_IMPLICIT_NO_DEFAULTS 0x08   


LIBYANG_API_DECL LY_ERR lyd_new_implicit_tree(struct lyd_node *tree, uint32_t implicit_options, struct lyd_node **diff);

LIBYANG_API_DECL LY_ERR lyd_new_implicit_all(struct lyd_node **tree, const struct ly_ctx *ctx, uint32_t implicit_options,
        struct lyd_node **diff);

LIBYANG_API_DECL LY_ERR lyd_new_implicit_module(struct lyd_node **tree, const struct lys_module *module,
        uint32_t implicit_options, struct lyd_node **diff);

LIBYANG_API_DECL LY_ERR lyd_change_term(struct lyd_node *term, const char *val_str);

LIBYANG_API_DECL LY_ERR lyd_change_term_canon(struct lyd_node *term, const char *val_str);

LIBYANG_API_DECL LY_ERR lyd_change_meta(struct lyd_meta *meta, const char *val_str);

LIBYANG_API_DECL LY_ERR lyd_insert_child(struct lyd_node *parent, struct lyd_node *node);

LIBYANG_API_DECL LY_ERR lyd_insert_sibling(struct lyd_node *sibling, struct lyd_node *node, struct lyd_node **first);

LIBYANG_API_DECL LY_ERR lyd_insert_before(struct lyd_node *sibling, struct lyd_node *node);

LIBYANG_API_DECL LY_ERR lyd_insert_after(struct lyd_node *sibling, struct lyd_node *node);

LIBYANG_API_DECL LY_ERR lyd_unlink_siblings(struct lyd_node *node);

LIBYANG_API_DECL LY_ERR lyd_unlink_tree(struct lyd_node *node);

LIBYANG_API_DECL void lyd_free_all(struct lyd_node *node);

LIBYANG_API_DECL void lyd_free_siblings(struct lyd_node *node);

LIBYANG_API_DECL void lyd_free_tree(struct lyd_node *node);

LIBYANG_API_DECL void lyd_free_meta_single(struct lyd_meta *meta);

LIBYANG_API_DECL void lyd_free_meta_siblings(struct lyd_meta *meta);

LIBYANG_API_DECL void lyd_free_attr_single(const struct ly_ctx *ctx, struct lyd_attr *attr);

LIBYANG_API_DECL void lyd_free_attr_siblings(const struct ly_ctx *ctx, struct lyd_attr *attr);

LIBYANG_API_DECL LY_ERR lyd_value_validate(const struct lysc_node *schema, const char *value, uint32_t value_len,
        const struct lyd_node *ctx_node, const struct lysc_type **realtype, const char **canonical);

LIBYANG_API_DECL LY_ERR lyd_value_validate_dflt(const struct lysc_node *schema, const char *value,
        struct lysc_prefix *prefixes, const struct lyd_node *ctx_node, const struct lysc_type **realtype,
        const char **canonical);

LIBYANG_API_DECL LY_ERR lyd_value_compare(const struct lyd_node_term *node, const char *value, uint32_t value_len);

#define LYD_COMPARE_FULL_RECURSION 0x01 /* Lists and containers are the same only in case all they children
                                           (subtree, so direct as well as indirect children) are the same. By default,
                                           containers are the same in case of the same schema node and lists are the same
                                           in case of equal keys (keyless lists do the full recursion comparison all the time). */
#define LYD_COMPARE_DEFAULTS 0x02       /* By default, implicit and explicit default nodes are considered to be equal. This flag
                                           changes this behavior and implicit (automatically created default node) and explicit
                                           (explicitly created node with the default value) default nodes are considered different. */
#define LYD_COMPARE_OPAQ 0x04           /* Opaque nodes can normally be never equal to data nodes. Using this flag even
                                           opaque nodes members are compared to data node schema and value and can result
                                           in a match. */

LIBYANG_API_DECL LY_ERR lyd_compare_single(const struct lyd_node *node1, const struct lyd_node *node2, uint32_t options);

LIBYANG_API_DECL LY_ERR lyd_compare_siblings(const struct lyd_node *node1, const struct lyd_node *node2, uint32_t options);

LIBYANG_API_DECL LY_ERR lyd_compare_meta(const struct lyd_meta *meta1, const struct lyd_meta *meta2);

 
#define LYD_DUP_RECURSIVE    0x01  
#define LYD_DUP_NO_META      0x02  
#define LYD_DUP_WITH_PARENTS 0x04  
#define LYD_DUP_WITH_FLAGS   0x08  
#define LYD_DUP_NO_EXT       0x10  
#define LYD_DUP_WITH_PRIV    0x20  
#define LYD_DUP_NO_LYDS      0x40  


LIBYANG_API_DECL LY_ERR lyd_dup_single(const struct lyd_node *node, struct lyd_node *parent, uint32_t options,
        struct lyd_node **dup);

LIBYANG_API_DECL LY_ERR lyd_dup_single_to_ctx(const struct lyd_node *node, const struct ly_ctx *trg_ctx,
        struct lyd_node *parent, uint32_t options, struct lyd_node **dup);

LIBYANG_API_DECL LY_ERR lyd_dup_siblings(const struct lyd_node *node, struct lyd_node *parent, uint32_t options,
        struct lyd_node **dup);

LIBYANG_API_DECL LY_ERR lyd_dup_siblings_to_ctx(const struct lyd_node *node, const struct ly_ctx *trg_ctx,
        struct lyd_node *parent, uint32_t options, struct lyd_node **dup);

LIBYANG_API_DECL LY_ERR lyd_dup_meta_single(const struct lyd_meta *meta, struct lyd_node *parent, struct lyd_meta **dup);

 
#define LYD_MERGE_DESTRUCT      0x01 
#define LYD_MERGE_DEFAULTS      0x02 
#define LYD_MERGE_WITH_FLAGS    0x04 


LIBYANG_API_DECL LY_ERR lyd_merge_tree(struct lyd_node **target, const struct lyd_node *source, uint16_t options);

LIBYANG_API_DECL LY_ERR lyd_merge_siblings(struct lyd_node **target, const struct lyd_node *source, uint16_t options);

typedef LY_ERR (*lyd_merge_cb)(struct lyd_node *trg_node, const struct lyd_node *src_node, void *cb_data);

LIBYANG_API_DECL LY_ERR lyd_merge_module(struct lyd_node **target, const struct lyd_node *source, const struct lys_module *mod,
        lyd_merge_cb merge_cb, void *cb_data, uint16_t options);

 
#define LYD_DIFF_DEFAULTS   0x01 
#define LYD_DIFF_META       0x02 


LIBYANG_API_DECL LY_ERR lyd_diff_tree(const struct lyd_node *first, const struct lyd_node *second, uint16_t options,
        struct lyd_node **diff);

LIBYANG_API_DECL LY_ERR lyd_diff_siblings(const struct lyd_node *first, const struct lyd_node *second, uint16_t options,
        struct lyd_node **diff);

typedef LY_ERR (*lyd_diff_cb)(const struct lyd_node *diff_node, struct lyd_node *data_node, void *cb_data);

LIBYANG_API_DECL LY_ERR lyd_diff_apply_module(struct lyd_node **data, const struct lyd_node *diff,
        const struct lys_module *mod, lyd_diff_cb diff_cb, void *cb_data);

LIBYANG_API_DECL LY_ERR lyd_diff_apply_all(struct lyd_node **data, const struct lyd_node *diff);

 
#define LYD_DIFF_MERGE_DEFAULTS   0x01 


LIBYANG_API_DECL LY_ERR lyd_diff_merge_module(struct lyd_node **diff, const struct lyd_node *src_diff,
        const struct lys_module *mod, lyd_diff_cb diff_cb, void *cb_data, uint16_t options);

LIBYANG_API_DECL LY_ERR lyd_diff_merge_tree(struct lyd_node **diff_first, struct lyd_node *diff_parent,
        const struct lyd_node *src_sibling, lyd_diff_cb diff_cb, void *cb_data, uint16_t options);

LIBYANG_API_DECL LY_ERR lyd_diff_merge_all(struct lyd_node **diff, const struct lyd_node *src_diff, uint16_t options);

 * @return LY_ERR on error.
 */
LIBYANG_API_DECL LY_ERR lyd_diff_reverse_all(const struct lyd_node *src_diff, struct lyd_node **diff);


typedef enum {
    LYD_PATH_STD, 
    LYD_PATH_STD_NO_LAST_PRED  
} LYD_PATH_TYPE;

LIBYANG_API_DECL char *lyd_path(const struct lyd_node *node, LYD_PATH_TYPE pathtype, char *buffer, size_t buflen);

LIBYANG_API_DECL struct lyd_meta *lyd_find_meta(const struct lyd_meta *first, const struct lys_module *module,
        const char *name);

LIBYANG_API_DECL LY_ERR lyd_find_sibling_first(const struct lyd_node *siblings, const struct lyd_node *target,
        struct lyd_node **match);

LIBYANG_API_DECL LY_ERR lyd_find_sibling_val(const struct lyd_node *siblings, const struct lysc_node *schema,
        const char *key_or_value, uint32_t val_len, struct lyd_node **match);

LIBYANG_API_DECL LY_ERR lyd_find_sibling_dup_inst_set(const struct lyd_node *siblings, const struct lyd_node *target,
        struct ly_set **set);

LIBYANG_API_DECL LY_ERR lyd_find_sibling_opaq_next(const struct lyd_node *first, const char *name, struct lyd_node **match);

LIBYANG_API_DECL LY_ERR lyxp_vars_set(struct lyxp_var **vars, const char *name, const char *value);

LIBYANG_API_DECL void lyxp_vars_free(struct lyxp_var *vars);

LIBYANG_API_DECL LY_ERR lyd_find_xpath(const struct lyd_node *ctx_node, const char *xpath, struct ly_set **set);

LIBYANG_API_DECL LY_ERR lyd_find_xpath2(const struct lyd_node *ctx_node, const char *xpath, const struct lyxp_var *vars,
        struct ly_set **set);

LIBYANG_API_DECL LY_ERR lyd_find_xpath3(const struct lyd_node *ctx_node, const struct lyd_node *tree, const char *xpath,
        LY_VALUE_FORMAT format, void *prefix_data, const struct lyxp_var *vars, struct ly_set **set);

LIBYANG_API_DECL LY_ERR lyd_eval_xpath(const struct lyd_node *ctx_node, const char *xpath, ly_bool *result);

LIBYANG_API_DECL LY_ERR lyd_eval_xpath2(const struct lyd_node *ctx_node, const char *xpath,
        const struct lyxp_var *vars, ly_bool *result);

 */
LIBYANG_API_DECL LY_ERR lyd_eval_xpath3(const struct lyd_node *ctx_node, const struct lys_module *cur_mod,
        const char *xpath, LY_VALUE_FORMAT format, void *prefix_data, const struct lyxp_var *vars, ly_bool *result);


typedef enum {
    LY_XPATH_NODE_SET,  
    LY_XPATH_STRING,    
    LY_XPATH_NUMBER,    
    LY_XPATH_BOOLEAN    
} LY_XPATH_TYPE;

LIBYANG_API_DECL LY_ERR lyd_eval_xpath4(const struct lyd_node *ctx_node, const struct lyd_node *tree,
        const struct lys_module *cur_mod, const char *xpath, LY_VALUE_FORMAT format, void *prefix_data,
        const struct lyxp_var *vars, LY_XPATH_TYPE *ret_type, struct ly_set **node_set, char **string,
        long double *number, ly_bool *boolean);

LIBYANG_API_DEF LY_ERR lyd_trim_xpath(struct lyd_node **tree, const char *xpath, const struct lyxp_var *vars);

LIBYANG_API_DECL LY_ERR lyd_find_path(const struct lyd_node *ctx_node, const char *path, ly_bool output,
        struct lyd_node **match);

LIBYANG_API_DECL LY_ERR lyd_find_target(const struct ly_path *path, const struct lyd_node *tree, struct lyd_node **match);

LIBYANG_API_DECL int ly_time_tz_offset(void);

LIBYANG_API_DECL int ly_time_tz_offset_at(time_t time);

LIBYANG_API_DECL LY_ERR ly_time_str2time(const char *value, time_t *time, char **fractions_s);

LIBYANG_API_DECL LY_ERR ly_time_time2str(time_t time, const char *fractions_s, char **str);

LIBYANG_API_DECL LY_ERR ly_time_str2ts(const char *value, struct timespec *ts);

LIBYANG_API_DECL LY_ERR ly_time_ts2str(const struct timespec *ts, char **str);

LIBYANG_API_DECL LY_ERR lyd_leafref_get_links(const struct lyd_node_term *node, const struct lyd_leafref_links_rec **record);

LIBYANG_API_DECL LY_ERR lyd_leafref_link_node_tree(const struct lyd_node *tree);

LIBYANG_API_DECL LY_ERR ly_pattern_match(const struct ly_ctx *ctx, const char *pattern, const char *string,
        uint32_t str_len, void **pat_comp);

LIBYANG_API_DECL LY_ERR ly_pattern_compile(const struct ly_ctx *ctx, const char *pattern, void **pat_comp);

LIBYANG_API_DECL void ly_pattern_free(void *pat_comp);
 
#ifdef __cplusplus
}
#endif
 
#endif /* LY_TREE_DATA_H_ */