module.c File Reference

#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include "debug.h"
#include "module.h"
#include "utils/list.h"

Include dependency graph for module.c:

Go to the source code of this file.

Macros
#define	MOD_NAME   "[module] "

Functions
void	append_message_path (char *buf, int buflen, const enum module_class *modules)
void	dump_parents (struct module *node)
void	dump_tree (struct module *root_node, int indent)
static struct module *	find_child (struct module *node, const char *node_name, int id_num, const char *id_name)
struct module *	get_matching_child (struct module *node, const char *const_path)
struct module *	get_module (struct module *root, const char *const_path)
static const char *	get_module_identifier (struct module *mod)
struct module *	get_parent_module (struct module *node)
static void	get_receiver_index (char *node_str, int *index, char **name)
struct module *	get_root_module (struct module *node)
const char *	module_class_name (enum module_class cls)
void	module_done (struct module *module_data)
bool	module_get_path_str (struct module *mod, char *buf, size_t buflen)
void	module_init_default (struct module *module_data)
static void	module_mutex_lock (pthread_mutex_t *lock)
static void	module_mutex_unlock (pthread_mutex_t *lock)
void	module_register (struct module *module_data, struct module *parent)

Variables
static const char *	module_class_name_pairs []

Detailed Description

Author

Martin Pulec pulec.nosp@m.@ces.nosp@m.net.c.nosp@m.z

Definition in file module.c.

Macro Definition Documentation

MOD_NAME

#define MOD_NAME   "[module] "

Definition at line 46 of file module.c.

Function Documentation

find_child()

static struct module * find_child ( struct module * node, const char * node_name, int id_num, const char * id_name )

static

id_num and id_name distinguish in case that the node has more child nodes with the same node_name (the same class). If id_name == NULL, id_num is used.

Definition at line 223 of file module.c.

{
        for(void *it = simple_linked_list_it_init(node->children); it != NULL; ) {
                struct module *child = (struct module *) simple_linked_list_it_next(&it);
                const char *child_name = module_class_name(child->cls);
                assert(child_name != NULL);
                if(strcasecmp(child_name, node_name) == 0) {
                        if (id_name != NULL) {
                                if (child->name && strcmp(child->name, id_name) == 0) {
                                        simple_linked_list_it_destroy(it);
                                        return child;
                                }
                        } else if (id_num-- == 0) {
                                simple_linked_list_it_destroy(it);
                                return child;
                        }
                }
        }
        return NULL;
}

References module::children, module::cls, module_class_name(), module::name, simple_linked_list_it_destroy(), simple_linked_list_it_init(), and simple_linked_list_it_next().

Referenced by get_matching_child().

Here is the call graph for this function:

get_module_identifier()

static const char * get_module_identifier ( struct module * mod )

static

Returns

module_class_name() if we are first child of our class

cls_name[idx] otherwise (idx > 0)

Definition at line 366 of file module.c.

{
        const char *cls_name = module_class_name(mod->cls);
        struct module *parent = get_parent_module(mod);
        if (parent == NULL) {
                return cls_name;
        }
 
        module_mutex_lock(&parent->lock);
 
        int our_index = 0;
        for (void *it = simple_linked_list_it_init(parent->children);
             it != NULL;) {
                struct module *child = simple_linked_list_it_next(&it);
                if (child->cls != mod->cls) {
                        continue;
                }
                if (child == mod) { // found our node
                        break;
                }
                our_index += 1;
        }
        if (our_index == 0) {
                module_mutex_unlock(&parent->lock);
                return cls_name;
        }
        // append our index if >0
        _Thread_local static char name[128];
        name[sizeof name - 1] = '\0';
        int ret = snprintf(name, sizeof name, "%s[%d]", cls_name, our_index);
        assert((unsigned)ret < sizeof name);
 
        module_mutex_unlock(&parent->lock);
 
        return name;
}

References module::cls, get_parent_module(), module_class_name(), module_mutex_lock(), module_mutex_unlock(), name, parent, simple_linked_list_it_init(), and simple_linked_list_it_next().

Referenced by module_get_path_str().

Here is the call graph for this function:

get_receiver_index()

static void get_receiver_index ( char * node_str, int * index, char ** name )

static

Parses path element, which might be either in form a single-word item (eg "display") or an array, either indexed by a number, in which case non-zero index will be returned or a module name (module::name member) which would be returned in name return value. Both indexing options are mutually exclusive.

Definition at line 251 of file module.c.

                                                                        {
        if (strchr(node_str, '[') && (strchr(node_str, ']') > strchr(node_str, '['))) {
                char *item = strchr(node_str, '[') + 1;
                *strchr(node_str, '[') = '\0';
                *strchr(item, ']') = '\0';
                if (isdigit(item[0])) {
                        *index = atoi(item);
                } else {
                        *name = item;
                }
        }
}

References name.

Referenced by get_matching_child().

module_mutex_lock()

static void module_mutex_lock ( pthread_mutex_t * lock )

static

Definition at line 69 of file module.c.

{
        MSG(DEBUG, "Locking lock %p\n", lock);
        pthread_mutex_lock(lock);
}

References DEBUG, and MSG.

Referenced by dump_tree(), get_module(), get_module_identifier(), module_done(), and module_register().

module_mutex_unlock()

static void module_mutex_unlock ( pthread_mutex_t * lock )

static

Definition at line 76 of file module.c.

{
        MSG(DEBUG, "Unlocking lock %p\n", lock);
        pthread_mutex_unlock(lock);
}

References DEBUG, and MSG.

Referenced by dump_tree(), get_module(), get_module_identifier(), module_done(), and module_register().

Variable Documentation

module_class_name_pairs

const char* module_class_name_pairs[]

static

Initial value:

= {
        [MODULE_CLASS_ROOT] = "root",
        [MODULE_CLASS_PORT] = "port",
        [MODULE_CLASS_COMPRESS] = "compress",
        [MODULE_CLASS_DATA] = "data",
        [MODULE_CLASS_SENDER] = "sender",
        [MODULE_CLASS_RECEIVER] = "receiver",
        [MODULE_CLASS_TX] = "transmit",
        [MODULE_CLASS_AUDIO] = "audio",
        [MODULE_CLASS_CONTROL] = "control",
        [MODULE_CLASS_CAPTURE] = "capture",
        [MODULE_CLASS_FILTER] = "filter",
        [MODULE_CLASS_DISPLAY] = "display",
        [MODULE_CLASS_DECODER] = "decoder",
        [MODULE_CLASS_EXPORTER] = "exporter",
        [MODULE_CLASS_KEYCONTROL] = "keycontrol",
}

Definition at line 160 of file module.c.

                                               {
        [MODULE_CLASS_ROOT] = "root",
        [MODULE_CLASS_PORT] = "port",
        [MODULE_CLASS_COMPRESS] = "compress",
        [MODULE_CLASS_DATA] = "data",
        [MODULE_CLASS_SENDER] = "sender",
        [MODULE_CLASS_RECEIVER] = "receiver",
        [MODULE_CLASS_TX] = "transmit",
        [MODULE_CLASS_AUDIO] = "audio",
        [MODULE_CLASS_CONTROL] = "control",
        [MODULE_CLASS_CAPTURE] = "capture",
        [MODULE_CLASS_FILTER] = "filter",
        [MODULE_CLASS_DISPLAY] = "display",
        [MODULE_CLASS_DECODER] = "decoder",
        [MODULE_CLASS_EXPORTER] = "exporter",
        [MODULE_CLASS_KEYCONTROL] = "keycontrol",
};

Referenced by module_class_name().