Exemplo n.º 1
0
static bool		*uf_string_fill_bool(t_string *v_this, const char *charset)
{
	size_t	i;
	size_t	size;
	bool	*active;

	i = 0;
	if ((active = uf_malloc_s(v_this->v_size, sizeof(*active))) == NULL)
		return ((bool *)M_ERROR((size_t)NULL, "Bad alloc"));
	uf_memset(active, false, v_this->v_size * sizeof(*active));
	size = uf_str_len(charset);
	if (size == 0)
		i = v_this->v_size;
	while (i < v_this->v_size)
	{
		if (uf_strncmp(v_this->v_str + i, charset, size) == 0)
		{
			uf_memset(active + i, true, size * sizeof(*active));
			i = i + size;
		}
		else
			i = i + 1;
	}
	return (active);
}
Exemplo n.º 2
0
bool		f_arqueue_init(t_arqueue *v_this, size_t elem_size, size_t nb_elem)
{
	v_this->v_start = 0;
	v_this->v_end = 0;
	v_this->v_size = 0;
	if ((v_this->v_array = uf_malloc_s(nb_elem, elem_size)) == NULL)
		return (M_ERROR(false, "Bad alloc"));
	v_this->v_capacity = nb_elem;
	v_this->v_sizeof = elem_size;
	return (true);
}
Exemplo n.º 3
0
t_list_cell			*f_list_cell_create(t_list_cell *prev,
										t_list_cell *next, void *data)
{
	t_list_cell	*cell;

	if ((cell = uf_malloc_s(1, sizeof(*cell))) != NULL)
	{
		cell->v_next = next;
		cell->v_prev = prev;
		cell->v_data = data;
	}
	return (cell);
}
Exemplo n.º 4
0
static bool		uf_string_dump_word(const char *str, char **tab,
									size_t size, size_t *word)
{
	if ((tab[*word] = uf_malloc_s(size + 1, sizeof(*tab[*word]))) == NULL)
	{
		uf_free_tab_fail((void **)tab, *word);
		return (false);
	}
	uf_memcpy(tab[*word], str, size * sizeof(*tab[*word]));
	tab[*word][size] = '\0';
	*word = *word + 1;
	tab[*word] = NULL;
	return (true);
}
Exemplo n.º 5
0
static t_unit_test	*uf_unit_alloc_test(const char *name,
										void (*test)(t_unit_test *))
{
	t_unit_test	*t;

	if ((t = uf_malloc_s(1, sizeof(*t))) == NULL)
		return ((t_unit_test*)M_ERROR((size_t)NULL, "Bad alloc"));
	t->v_name = name;
	t->f_func = test;
	t->v_failed = false;
	t->v_active = true;
	t->v_tested = false;
	D_LIST(init)(&t->v_assert, free);
	return (t);
}
Exemplo n.º 6
0
bool					f_string_init(t_string *v_this,
									size_t (*uf_realloc)(size_t size))
{
	size_t	size;

	size = 2;
	v_this->v_size = 0;
	if ((v_this->v_str = uf_malloc_s(size, sizeof(*v_this->v_str))) == NULL)
		return (M_ERROR(false, "Bad alloc"));
	uf_memset(v_this->v_str, 0, size * sizeof(*v_this->v_str));
	v_this->f_realloc = uf_string_realloc_value;
	if (uf_realloc != NULL)
		v_this->f_realloc = uf_realloc;
	v_this->v_capacity = size;
	v_this->v_hex = "0123456789ABCDEF";
	return (true);
}
Exemplo n.º 7
0
bool					f_array_init(t_array *v_this,
							size_t (*uf_realloc)(size_t size),
							void (*uf_delete)(void *ptr), size_t type_size)
{
	v_this->v_size = 0;
	v_this->v_capacity = 0;
	v_this->f_realloc = uf_realloc;
	if (uf_realloc == NULL)
		v_this->f_realloc = uf_array_realloc;
	v_this->f_delete = uf_delete;
	if (uf_delete == NULL)
		v_this->f_delete = uf_array_delete;
	if ((v_this->v_data = uf_malloc_s(2, type_size)) == NULL)
		return (M_ERROR(false, "Bad alloc"));
	uf_memset(v_this->v_data, 0, 2 * type_size);
	v_this->v_capacity = 2;
	v_this->v_type_size = type_size;
	return (true);
}
Exemplo n.º 8
0
bool				f_unit_add_context(t_unit *v_this, const char *name,
									bool (*init)(void *),
									bool (*destroy)(void *))
{
	t_unit_context	*context;

	if ((context = uf_malloc_s(1, sizeof(*context))) == NULL)
		return (M_ERROR(false, "Bad alloc"));
	context->v_name = name;
	context->f_init = init;
	context->f_destroy = destroy;
	context->v_id = D_LIST(size)(&v_this->v_context) + 1;
	D_LIST(init)(&context->v_test, uf_unit_destroy_test);
	if (D_LIST(push_back)(&v_this->v_context, context) == false)
	{
		uf_free_s((void **)&context);
		return (false);
	}
	return (true);
}
Exemplo n.º 9
0
bool		f_threadpool_init(t_threadpool *v_this, size_t nb_thread)
{
	t_threadpool_data	*data;

	v_this->pv_data.v_run = false;
	if ((v_this->v_id = uf_malloc_s(nb_thread, sizeof(*v_this->v_id))) == NULL)
		return (M_ERROR(false, "Bad alloc"));
	D_QUEUE(init)(&v_this->pv_data.v_tasks, free);
	if (D_LOCK(init)(&v_this->v_data, &v_this->pv_data,
					e_lock_default) == false)
	{
		uf_free_s((void **)&v_this->v_id);
		return (M_ERROR(false, "Couldn't initialize lock"));
	}
	if (D_LOCK(lock)(&v_this->v_data, (void **)&data) == true)
		return (D_THREADPOOL(create)(v_this, data, nb_thread));
	D_LOCK(destroy)(&v_this->v_data);
	uf_free_s((void **)&v_this->v_id);
	return (M_ERROR(false, "An error has occured"));
}
Exemplo n.º 10
0
bool		f_threadpool_add_task(t_threadpool *v_this,
									t_threadpool_task *task)
{
	t_threadpool_task	*add;
	t_threadpool_data	*data;

	if ((add = uf_malloc_s(1, sizeof(*add))) == NULL)
		return (M_ERROR(false, "Bad alloc"));
	uf_memcpy(add, task, sizeof(*add));
	if (D_LOCK(lock)(&v_this->v_data, (void **)&data) == true)
	{
		if (D_QUEUE(push)(&data->v_tasks, add) == false)
		{
			uf_free_s((void **)&add);
			D_LOCK(release)(&v_this->v_data, (void **)&data);
			return (M_ERROR(false, "Couldn't add tasks"));
		}
		D_LOCK(release)(&v_this->v_data, (void **)&data);
		return (true);
	}
	uf_free_s((void **)&add);
	return (false);
}