node.h

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright 2016, Olivier MATZ <zer0@droids-corp.org>
 */

 
#pragma once
 
#include <stdbool.h>
#include <stdio.h>
#include <sys/queue.h>
#include <sys/types.h>

#define EC_NO_ID ""

struct ec_node;

struct ec_node_iter;
 
struct ec_pnode;
struct ec_comp;
struct ec_strvec;
struct ec_dict;
struct ec_config;
struct ec_config_schema;

#define EC_NODE_TYPE_REGISTER(t)                                                                   \
    static void ec_node_init_##t(void);                                                        \
    static void __attribute__((constructor, used)) ec_node_init_##t(void)                      \
    {                                                                                          \
        if (ec_node_type_register(&t, 0) < 0)                                              \
            fprintf(stderr, "cannot register node type %s\n", t.name);                 \
    }

#define EC_NODE_TYPE_REGISTER_OVERRIDE(t)                                                          \
    static void ec_node_init_##t(void);                                                        \
    static void __attribute__((constructor, used)) ec_node_init_##t(void)                      \
    {                                                                                          \
        if (ec_node_type_register(&t, 1) < 0)                                              \
            fprintf(stderr, "cannot register node type %s\n", t.name);                 \
    }

typedef int (*ec_node_set_config_t)(struct ec_node *node, const struct ec_config *config);

typedef int (*ec_parse_t)(
    const struct ec_node *node,
    struct ec_pnode *pstate,
    const struct ec_strvec *strvec
);

typedef int (*ec_complete_t)(
    const struct ec_node *node,
    struct ec_comp *comp,
    const struct ec_strvec *strvec
);

typedef char *(*ec_node_desc_t)(const struct ec_node *);

typedef int (*ec_node_init_priv_t)(struct ec_node *);

typedef void (*ec_node_free_priv_t)(struct ec_node *);

typedef size_t (*ec_node_get_children_count_t)(const struct ec_node *);

typedef int (*ec_node_get_child_t)(
    const struct ec_node *,
    size_t i,
    struct ec_node **child,
    unsigned int *refs
);

struct ec_node_type {
    TAILQ_ENTRY(ec_node_type) next; 
    const char *name; 
    const struct ec_config_schema *schema;
    size_t size; 
    ec_node_set_config_t set_config; 
    ec_parse_t parse; 
    ec_complete_t complete; 
    ec_node_desc_t desc; 
    ec_node_init_priv_t init_priv; 
    ec_node_free_priv_t free_priv; 
    ec_node_get_children_count_t get_children_count;
    ec_node_get_child_t get_child; 
};

TAILQ_HEAD(ec_node_type_list, ec_node_type);

extern struct ec_node_type_list node_type_list;

int ec_node_type_register(struct ec_node_type *type, bool override);

const struct ec_node_type *ec_node_type_lookup(const char *name);

void ec_node_type_dump(FILE *out);

const struct ec_config_schema *ec_node_type_schema(const struct ec_node_type *type);

const char *ec_node_type_name(const struct ec_node_type *type);

struct ec_node *ec_node_from_type(const struct ec_node_type *type, const char *id);

struct ec_node *ec_node(const char *typename, const char *id);

struct ec_node *ec_node_clone(struct ec_node *node);

void ec_node_free(struct ec_node *node);

int ec_node_set_config(struct ec_node *node, struct ec_config *config);

const struct ec_config *ec_node_get_config(const struct ec_node *node);

size_t ec_node_get_children_count(const struct ec_node *node);

int ec_node_get_child(const struct ec_node *node, size_t i, struct ec_node **child);

const struct ec_node_type *ec_node_type(const struct ec_node *node);

struct ec_dict *ec_node_attrs(const struct ec_node *node);

const char *ec_node_id(const struct ec_node *node);

char *ec_node_desc(const struct ec_node *node);

void ec_node_dump(FILE *out, const struct ec_node *node);

struct ec_node *ec_node_find(struct ec_node *node, const char *id);

struct ec_node_iter *ec_node_iter(struct ec_node *node);

struct ec_node_iter *
ec_node_iter_next(struct ec_node_iter *root, struct ec_node_iter *iter, bool iter_children);

void ec_node_iter_free(struct ec_node_iter *iter);

struct ec_node *ec_node_iter_get_node(struct ec_node_iter *iter);

struct ec_node_iter *ec_node_iter_get_parent(struct ec_node_iter *iter);

int ec_node_check_type(const struct ec_node *node, const struct ec_node_type *type);

const char *ec_node_get_type_name(const struct ec_node *node);

void *ec_node_priv(const struct ec_node *node);

void ec_node_schema_dump(FILE *out, const struct ec_node *node);