tree_data.h

Go to the documentation of this file.

#ifndef LY_TREE_DATA_H_
#define LY_TREE_DATA_H_

#include <stddef.h>
#include <stdint.h>

#include "libyang.h"
#include "tree_schema.h"
#include "xml.h"

#ifdef __cplusplus
extern "C" {
#endif

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

typedef enum {
    LYD_ANYDATA_CONSTSTRING = 0x00, 
    LYD_ANYDATA_STRING = 0x01,      
    LYD_ANYDATA_JSON = 0x02,        
    LYD_ANYDATA_JSOND = 0x03,       
    LYD_ANYDATA_SXML = 0x04,        
    LYD_ANYDATA_SXMLD = 0x05,       
    LYD_ANYDATA_XML = 0x08,         
    LYD_ANYDATA_DATATREE = 0x10,    
    LYD_ANYDATA_LYB = 0x20,         
    LYD_ANYDATA_LYBD = 0x21,        
} LYD_ANYDATA_VALUETYPE;

typedef union lyd_value_u {
    const char *binary;          
    struct lys_type_bit **bit;   
    int8_t bln;                  
    int64_t dec64;               
    struct lys_type_enum *enm;   
    struct lys_ident *ident;     
    struct lyd_node *instance;   
    int8_t int8;                 
    int16_t int16;               
    int32_t int32;               
    int64_t int64;               
    struct lyd_node *leafref;    
    const char *string;          
    uint8_t uint8;               
    uint16_t uint16;             
    uint32_t uint32;             
    uint64_t uint64;             
    void *ptr;                   
} lyd_val;

struct lyd_attr {
    struct lyd_node *parent;         
    struct lyd_attr *next;           
    struct lys_ext_instance_complex *annotation; 
    const char *name;                
    const char *value_str;           
    lyd_val value;                   
    LY_DATA_TYPE _PACKED value_type; 
    uint8_t value_flags;             
};

#define LYD_VAL_OK       0x00    
#define LYD_VAL_DUP      0x01    
#define LYD_VAL_UNIQUE   0x02    
#define LYD_VAL_MAND     0x04    
#define LYD_VAL_INUSE    0x80    
struct lyd_node {
    struct lys_node *schema;         
    uint8_t validity;                
    uint8_t dflt:1;                  
    uint8_t when_status:3;           
    struct lyd_attr *attr;           
    struct lyd_node *next;           
    struct lyd_node *prev;           
    struct lyd_node *parent;         
#ifdef LY_ENABLED_LYD_PRIV
    void *priv;                      
#endif

#ifdef LY_ENABLED_CACHE
    uint32_t hash;                   
    struct hash_table *ht;           
#endif

    struct lyd_node *child;          
};

struct lyd_node_leaf_list {
    struct lys_node *schema;         
    uint8_t validity;                
    uint8_t dflt:1;                  
    uint8_t when_status:3;           
    struct lyd_attr *attr;           
    struct lyd_node *next;           
    struct lyd_node *prev;           
    struct lyd_node *parent;         
#ifdef LY_ENABLED_LYD_PRIV
    void *priv;                      
#endif

#ifdef LY_ENABLED_CACHE
    uint32_t hash;                   
#endif

    /* struct lyd_node *child; should be here, but is not */

    /* leaflist's specific members */
    const char *value_str;           
    lyd_val value;                   
    LY_DATA_TYPE _PACKED value_type; 
    uint8_t value_flags;             
};

#define LY_VALUE_UNRES 0x01   
#define LY_VALUE_USER 0x02    
/* 0x80 is reserved for internal use */

typedef union {
    const char *str;             
    char *mem;                   
    struct lyxml_elem *xml;      
    struct lyd_node *tree;       
} lyd_anydata_value;

struct lyd_node_anydata {
    struct lys_node *schema;         
    uint8_t validity;                
    uint8_t dflt:1;                  
    uint8_t when_status:3;           
    struct lyd_attr *attr;           
    struct lyd_node *next;           
    struct lyd_node *prev;           
    struct lyd_node *parent;         
#ifdef LY_ENABLED_LYD_PRIV
    void *priv;                      
#endif

#ifdef LY_ENABLED_CACHE
    uint32_t hash;                   
#endif

    /* struct lyd_node *child; should be here, but is not */

    /* anyxml's specific members */
    LYD_ANYDATA_VALUETYPE value_type;
    lyd_anydata_value value;
};

typedef enum {
    LYD_DIFF_END = 0,        
    LYD_DIFF_DELETED,        
    LYD_DIFF_CHANGED,        
    LYD_DIFF_MOVEDAFTER1,    
    LYD_DIFF_CREATED,        
    LYD_DIFF_MOVEDAFTER2     
} LYD_DIFFTYPE;

struct lyd_difflist {
    LYD_DIFFTYPE *type;      
    struct lyd_node **first; 
    struct lyd_node **second;
};

void lyd_free_diff(struct lyd_difflist *diff);

struct lyd_difflist *lyd_diff(struct lyd_node *first, struct lyd_node *second, int options);

/* LYD_DIFFOPT_NOSIBLINGS value is the same as LYD_OPT_NOSIBLINGS due to backward compatibility. The LYD_OPT_NOSIBLINGS
 * was used previously as an option for lyd_diff(). */
#define LYD_DIFFOPT_NOSIBLINGS   0x0800 
#define LYD_DIFFOPT_WITHDEFAULTS 0x0001 
char *lyd_path(const struct lyd_node *node);

#define LYD_OPT_DATA       0x00 
#define LYD_OPT_CONFIG     0x01 
#define LYD_OPT_GET        0x02 
#define LYD_OPT_GETCONFIG  0x04 
#define LYD_OPT_EDIT       0x08 
#define LYD_OPT_RPC        0x10 
#define LYD_OPT_RPCREPLY   0x20 
#define LYD_OPT_NOTIF      0x40 
#define LYD_OPT_NOTIF_FILTER 0x80 
#define LYD_OPT_TYPEMASK   0x10000ff 
/* 0x100 reserved, used internally */
#define LYD_OPT_STRICT     0x0200 
#define LYD_OPT_DESTRUCT   0x0400 
#define LYD_OPT_OBSOLETE   0x0800 
#define LYD_OPT_NOSIBLINGS 0x1000 
#define LYD_OPT_TRUSTED    0x2000 
#define LYD_OPT_WHENAUTODEL 0x4000 
#define LYD_OPT_NOEXTDEPS  0x8000 
#define LYD_OPT_DATA_NO_YANGLIB  0x10000 
#define LYD_OPT_DATA_ADD_YANGLIB 0x20000 
#define LYD_OPT_VAL_DIFF 0x40000 
#define LYD_OPT_LYB_MOD_UPDATE 0x80000 
#define LYD_OPT_DATA_TEMPLATE 0x1000000 
#define LYD_OPT_MULTI_ERRORS  0x2000000 
struct lyd_node *lyd_parse_mem(struct ly_ctx *ctx, const char *data, LYD_FORMAT format, int options, ...);

struct lyd_node *lyd_parse_fd(struct ly_ctx *ctx, int fd, LYD_FORMAT format, int options, ...);

struct lyd_node *lyd_parse_path(struct ly_ctx *ctx, const char *path, LYD_FORMAT format, int options, ...);

struct lyd_node *lyd_parse_xml(struct ly_ctx *ctx, struct lyxml_elem **root, int options,...);

struct lyd_node *lyd_new(struct lyd_node *parent, const struct lys_module *module, const char *name);

struct lyd_node *lyd_new_leaf(struct lyd_node *parent, const struct lys_module *module, const char *name,
                              const char *val_str);

int lyd_change_leaf(struct lyd_node_leaf_list *leaf, const char *val_str);

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);

struct lyd_node *lyd_new_output(struct lyd_node *parent, const struct lys_module *module, const char *name);

struct lyd_node *lyd_new_output_leaf(struct lyd_node *parent, const struct lys_module *module, const char *name,
                                     const char *val_str);

struct lyd_node *lyd_new_output_anydata(struct lyd_node *parent, const struct lys_module *module, const char *name,
                                        void *value, LYD_ANYDATA_VALUETYPE value_type);

struct lyd_node *lyd_new_yangdata(const struct lys_module *module, const char *name_template, const char *name);

#define LYD_PATH_OPT_UPDATE   0x01 
#define LYD_PATH_OPT_NOPARENT 0x02 
#define LYD_PATH_OPT_OUTPUT   0x04 
#define LYD_PATH_OPT_DFLT     0x08 
#define LYD_PATH_OPT_NOPARENTRET 0x10 
#define LYD_PATH_OPT_EDIT     0x20 
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);

unsigned int lyd_list_pos(const struct lyd_node *node);

#define LYD_DUP_OPT_RECURSIVE    0x01 
#define LYD_DUP_OPT_NO_ATTR      0x02 
#define LYD_DUP_OPT_WITH_PARENTS 0x04 
#define LYD_DUP_OPT_WITH_KEYS    0x08 
#define LYD_DUP_OPT_WITH_WHEN    0x10 
struct lyd_node *lyd_dup(const struct lyd_node *node, int options);

struct lyd_node *lyd_dup_withsiblings(const struct lyd_node *node, int options);

struct lyd_node *lyd_dup_to_ctx(const struct lyd_node *node, int options, struct ly_ctx *ctx);

int lyd_merge(struct lyd_node *target, const struct lyd_node *source, int options);

int lyd_merge_to_ctx(struct lyd_node **trg, const struct lyd_node *src, int options, struct ly_ctx *ctx);

#define LYD_OPT_EXPLICIT 0x0100

int lyd_insert(struct lyd_node *parent, struct lyd_node *node);

int lyd_insert_sibling(struct lyd_node **sibling, struct lyd_node *node);

int lyd_insert_before(struct lyd_node *sibling, struct lyd_node *node);

int lyd_insert_after(struct lyd_node *sibling, struct lyd_node *node);

int lyd_schema_sort(struct lyd_node *sibling, int recursive);

struct ly_set *lyd_find_path(const struct lyd_node *ctx_node, const char *path);

struct ly_set *lyd_find_instance(const struct lyd_node *data, const struct lys_node *schema);

int lyd_find_sibling(const struct lyd_node *siblings, const struct lyd_node *target, struct lyd_node **match);

int lyd_find_sibling_set(const struct lyd_node *siblings, const struct lyd_node *target, struct ly_set **set);

int lyd_find_sibling_val(const struct lyd_node *siblings, const struct lys_node *schema, const char *key_or_value,
                         struct lyd_node **match);

struct lyd_node *lyd_first_sibling(struct lyd_node *node);

int lyd_validate(struct lyd_node **node, int options, void *var_arg, ...);

int lyd_validate_modules(struct lyd_node **node, const struct lys_module **modules, int mod_count, int options, ...);

void lyd_free_val_diff(struct lyd_difflist *diff);

int lyd_validate_value(struct lys_node *node, const char *value);

int lyd_value_type(struct lys_node *node, const char *value, struct lys_type **type);

int lyd_wd_default(struct lyd_node_leaf_list *node);

int lyd_node_should_print(const struct lyd_node *node, int options);

int lyd_unlink(struct lyd_node *node);

void lyd_free(struct lyd_node *node);

void lyd_free_withsiblings(struct lyd_node *node);

struct lyd_attr *lyd_insert_attr(struct lyd_node *parent, const struct lys_module *mod, const char *name,
                                 const char *value);

void lyd_free_attr(struct ly_ctx *ctx, struct lyd_node *parent, struct lyd_attr *attr, int recursive);

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

const struct lys_type *lyd_leaf_type(const struct lyd_node_leaf_list *leaf);

int lyd_print_mem(char **strp, const struct lyd_node *root, LYD_FORMAT format, int options);

int lyd_print_fd(int fd, const struct lyd_node *root, LYD_FORMAT format, int options);

int lyd_print_file(FILE *f, const struct lyd_node *root, LYD_FORMAT format, int options);

int lyd_print_path(const char *path, const struct lyd_node *root, LYD_FORMAT format, int options);

int lyd_print_clb(ssize_t (*writeclb)(void *arg, const void *buf, size_t count), void *arg,
                  const struct lyd_node *root, LYD_FORMAT format, int options);

double lyd_dec64_to_double(const struct lyd_node *node);

int lyd_lyb_data_length(const char *data);

#ifdef LY_ENABLED_LYD_PRIV

void *lyd_set_private(const struct lyd_node *node, void *priv);

struct lyd_node *lyd_find_path_hash_based(struct lyd_node *data_tree, const struct ly_ctx *ctx, const char *path,
                                          int output);

#endif

#ifdef __cplusplus
}
#endif

#endif /* LY_TREE_DATA_H_ */