Libyang.hpp

Go to the documentation of this file.

#ifndef LIBYANG_CPP_H
#define LIBYANG_CPP_H

#include <iostream>
#include <memory>
#include <exception>
#include <functional>
#include <vector>

#include "Internal.hpp"

extern "C" {
#include "libyang.h"
}

namespace libyang {

class Context
{
public:
    Context(struct ly_ctx *ctx, S_Deleter deleter);
    explicit Context(const char *search_dir = nullptr, int options = 0);
    Context(const char *search_dir, const char *path, LYD_FORMAT format, int options = 0);
    Context(const char *search_dir, LYD_FORMAT format, const char *data, int options = 0);
    ~Context();
    int set_searchdir(const char *search_dir);
    void unset_searchdirs(int idx) {return ly_ctx_unset_searchdirs(ctx, idx);};
    std::vector<std::string> get_searchdirs();
    void set_allimplemented() {return ly_ctx_set_allimplemented(ctx);};
    void unset_allimplemented() {return ly_ctx_unset_allimplemented(ctx);};
    void set_disable_searchdirs() {return ly_ctx_set_disable_searchdirs(ctx);};
    void unset_disable_searchdirs() {return ly_ctx_unset_disable_searchdirs(ctx);};
    void set_disable_searchdir_cwd() {return ly_ctx_set_disable_searchdir_cwd(ctx);};
    void unset_disable_searchdir_cwd() {return ly_ctx_unset_disable_searchdir_cwd(ctx);};
    void set_prefer_searchdirs() {return ly_ctx_set_prefer_searchdirs(ctx);};
    void unset_prefer_searchdirs() {return ly_ctx_unset_prefer_searchdirs(ctx);};
    S_Data_Node info();
    std::vector<S_Module> get_module_iter();
    std::vector<S_Module> get_disabled_module_iter();
    S_Module get_module(const char *name, const char *revision = nullptr, int implemented = 0);
    S_Module get_module_older(S_Module module);
    S_Module load_module(const char *name, const char *revision = nullptr);
    S_Module get_module_by_ns(const char *ns, const char *revision = nullptr, int implemented = 0);
    S_Submodule get_submodule(const char *module, const char *revision = nullptr, const char *submodule = nullptr, const char *sub_revision = nullptr);
    S_Submodule get_submodule2(S_Module main_module, const char *submodule = nullptr);
    S_Schema_Node get_node(S_Schema_Node start, const char *data_path, int output = 0);
    std::vector<S_Schema_Node> data_instantiables(int options);
    S_Set find_path(const char *schema_path);
    void clean();

    struct mod_missing_cb_return {
        LYS_INFORMAT format;
        const char *data;
    };
    using mod_missing_cb_t = std::function<mod_missing_cb_return(const char *mod_name, const char *mod_rev, const char *submod_name, const char *sub_rev)>;
    using mod_missing_deleter_t = std::function<void(void *)>;
    void add_missing_module_callback(const mod_missing_cb_t &callback, const mod_missing_deleter_t &deleter = mod_missing_deleter_t());

    /* functions */
    S_Data_Node parse_data_mem(const char *data, LYD_FORMAT format, int options = 0);
    S_Data_Node parse_data_fd(int fd, LYD_FORMAT format, int options = 0);
    S_Data_Node parse_data_path(const char *path, LYD_FORMAT format, int options = 0);
    S_Data_Node parse_data_xml(S_Xml_Elem elem, int options = 0);
    S_Module parse_module_mem(const char *data, LYS_INFORMAT format);
    S_Module parse_module_fd(int fd, LYS_INFORMAT format);
    S_Module parse_module_path(const char *path, LYS_INFORMAT format);

    friend std::vector<S_Error> get_ly_errors(S_Context context);
    friend Data_Node;
    friend Deleter;
    friend Error;

    std::vector<std::pair<mod_missing_cb_t, mod_missing_deleter_t>> mod_missing_cb;
    std::vector<const mod_missing_deleter_t *> mod_missing_deleter;
    static const char* cpp_mod_missing_cb(const char *mod_name, const char *mod_rev, const char *submod_name, const char *sub_rev, void *user_data, LYS_INFORMAT *format, void(**free_module_data)(void *model_data, void *user_data));
    static void cpp_mod_missing_deleter(void *data, void *user_data);

    /* SWIG specific */
    struct ly_ctx *swig_ctx() {return ctx;};
    std::vector<void*> wrap_cb_l;
private:
    struct ly_ctx *ctx;
    S_Deleter deleter;
};

S_Context create_new_Context(struct ly_ctx *ctx);

class Error
{
public:
    Error(struct ly_err_item *eitem);
    ~Error() {};
    LY_ERR err() throw() {return eitem->no;};
    LY_VECODE vecode() throw() {return eitem->vecode;};
    const char *errmsg() const throw() {return eitem->msg ? eitem->msg : "";};
    const char *errpath() const throw() {return eitem->path ? eitem->path : "";};
    const char *errapptag() const throw() {return eitem->apptag ? eitem->path : "";};
private:
    struct ly_err_item *eitem;
};

std::vector<S_Error> get_ly_errors(S_Context context);
int set_log_options(int options);
LY_LOG_LEVEL set_log_verbosity(LY_LOG_LEVEL level);

class Set
{
public:
    Set(struct ly_set *set, S_Deleter);
    Set();
    ~Set();
    unsigned int size() {return set->size;};
    unsigned int number() {return set->number;};
    std::vector<S_Data_Node> data();
    std::vector<S_Schema_Node> schema();

    /* functions */
    S_Set dup();
    int add(S_Data_Node node, int options = 0);
    int add(S_Schema_Node node, int options = 0);
    int contains(S_Data_Node node);
    int contains(S_Schema_Node node);
    int clean();
    int rm(S_Data_Node node);
    int rm(S_Schema_Node node);
    int rm_index(unsigned int index);

private:
    struct ly_set *set;
    S_Deleter deleter;
};

}

#endif