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_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);                 \
    }

TAILQ_HEAD(ec_node_type_list, ec_node_type);

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

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);
 
/* set configuration of a node
 * after a call to this function, the config is
 * owned by the node and must not be used by the caller
 * on error, the config is freed. */
int ec_node_set_config(struct ec_node *node, struct ec_config *config);
 
/* get the current node configuration. Return NULL if no configuration. */
const struct ec_config *ec_node_get_config(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,
    unsigned int *refs
);
 
/* XXX add more accessors */
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);
 
/* check the type of a node */
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);