sources/parallel/parallel_events.c

Go to the documentation of this file.

/*
** Copyright 2009-2011, helixis.org
** All rights reserved.
**
** Redistribution and use in source and binary forms, with or without modification, are permitted provided
** that the following conditions are met:
**
** Redistributions of source code must retain the above copyright notice, this list of conditions and the
** following disclaimer.
**
** Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
** the following disclaimer in the documentation and/or other materials provided with the distribution.
**
** Neither the name of the helixis.org nor the names of its contributors may be used to endorse or promote
** products derived from this software without specific prior written permission.
**
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
** WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
** PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
** ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
** TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
** HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
** NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
** POSSIBILITY OF SUCH DAMAGE.
*/

/*
** INCLUDES
*/

#include "hlx/core.h"
#include "helixis_internal.h"

#if defined(HLX_BUILD_WITH_PARALLEL_THREADING)

#ifdef __cplusplus
extern "C"      {
#endif

/*
** EXTERNALS
*/

extern hlx_api gl_api;
extern hlx_scheduler    gl_scheduler;
extern hlx_event_manager*       gl_event_manager;

/*
** FUNCTIONS
*/

hlx_event_manager*              hlx_event_manager_create()
{
        _hlx_event_manager*     manager;

        if ((manager = gl_api.malloc_entry(sizeof(*manager))) == 0)
                return 0;
        slist_new(&manager->handlers, 0, 0);
        return ((hlx_event_manager*)manager);
}

void                                    hlx_event_manager_destroy(hlx_event_manager* manager)
{
        struct slist_element*   it;
        _hlx_event_handler*     handler;

        it = 0;
        while (slist_get_head_and_then_next(((_hlx_event_manager*)manager)->handlers, &it))
        {
                slist_get_user_data_from_element(it, (void **)&handler);
                _hlx_event_handler_destroy(handler);
                gl_api.free_entry(handler);
        }
        slist_delete(((_hlx_event_manager*)manager)->handlers);
        _hlx_event_default_manager_destroy();
}

hlx_event_errors                _hlx_event_handler_create_by_hash(_hlx_event_manager* manager, unsigned long id, unsigned int size)
{
        _hlx_event_handler*     handler;

        if (_hlx_event_return_handler_by_hash(manager, id))
                return (EV_ERROR_ALREADY_EXISTS);
        if ((handler = gl_api.malloc_entry(sizeof(*handler))) == 0)
                return (EV_ERROR_MEMORY_EXHAUSTED);
        handler->hash_code = id;
        if (slist_new(&handler->callbacks, _hlx_event_delete_callback, 0) == 0 || slist_new_head(manager->handlers, handler) == 0)
                return (EV_ERROR_MEMORY_EXHAUSTED);
        handler->param_size = size;
        return (EV_ERROR_SUCCESS);
}

void    _hlx_event_handler_destroy(_hlx_event_handler* handler)
{
        slist_delete_all_elements(handler->callbacks);
}

hlx_event_errors                        _hlx_event_register_callback_with_group(_hlx_event_manager* manager, _hlx_event_handler* handler, unsigned long id, _hlx_event_callback* callback, hlx_group_id group_id)
{
        HLX_UNUSED(id);
        HLX_UNUSED(manager);
        callback->group_id = group_id;
        if (slist_new_head(handler->callbacks, callback) == 0)
        {
                gl_api.free_entry(callback);
                return (EV_ERROR_MEMORY_EXHAUSTED);
        }
        return (EV_ERROR_SUCCESS);
}

_hlx_event_handler*                     _hlx_event_return_handler_by_hash(_hlx_event_manager* manager, unsigned long id)
{
        _hlx_event_handler*             handler;
        struct slist_element*   it;

        it = 0;
        while (slist_get_head_and_then_next(manager->handlers, &it))
                if (slist_get_user_data_from_element(it, (void **)&handler) && handler->hash_code == id)
                        return (handler);
        return (0);
}

hlx_event_errors                        hlx_event_notify(hlx_event_manager* manager, unsigned long id, void* event_data)
{
        _hlx_event_handler*             handler;
        _hlx_event_callback*    callback;
        hlx_event_args*                 task_args;
        hlx_event_args                  func_args;
        struct slist_element*   it;

        if ((handler = _hlx_event_return_handler((_hlx_event_manager*)manager, id)) == 0)
                return (EV_ERROR_UNDEFINED);
        if (handler->param_size && event_data == 0)
                return (EV_ERROR_NO_EVENT_DATA);
        func_args.event_data = event_data;
        func_args.callback = 0;
        it = 0;
        while (slist_get_head_and_then_next(handler->callbacks, &it))
        {
                slist_get_user_data_from_element(it, (void **)&callback);
                if (callback->func)
                {
                        func_args.user_data = callback->params.user_data;
                        callback->func(&func_args);
                }
                if (callback->task)
                {
                        if ((task_args = gl_api.malloc_entry(sizeof(hlx_event_args))) == 0)
                                return (EV_ERROR_MEMORY_EXHAUSTED);
                        task_args->user_data = callback->params.user_data;
                        task_args->callback = callback->params.callback;
                        if (handler->param_size)
                        {
                                if ((task_args->event_data = gl_api.malloc_entry(handler->param_size)) == 0)
                                        return (EV_ERROR_MEMORY_EXHAUSTED);
                                gl_api.memcpy_entry(task_args->event_data, event_data, handler->param_size);
                        }
                        else
                                task_args->event_data = 0;
                        if (callback->group_id > 0)
                                hlx_core_add_task_in_group_callback(callback->task, task_args, callback->group_id, 0, _hlx_event_task_callback);
                        else
                                hlx_core_add_task_callback(callback->task, task_args, 0, _hlx_event_task_callback);
                }
        }
        return (EV_ERROR_SUCCESS);
}

#endif /* HLX_BUILD_WITH_PARALLEL_THREADING */

#ifdef __cplusplus
}
#endif

/*
** END OF FILE
*/