rz_idpool.h File Reference

#include <rz_vector.h>
#include <rz_types.h>
#include <rz_list.h>

Go to the source code of this file.

Classes
struct	rz_id_pool_t
struct	rz_id_storage_t
struct	rz_ordered_id_storage_t

Typedefs
typedef struct rz_id_pool_t	RzIDPool
typedef struct rz_id_storage_t	RzIDStorage
typedef bool(*	RzIDStorageForeachCb) (void *user, void *data, ut32 id)
typedef bool(*	ROIDStorageCompareCb) (void *in, void *incoming, void *user, int *cmp_res)
typedef struct rz_ordered_id_storage_t	ROIDStorage

Functions
RZ_API RzIDPool *	rz_id_pool_new (ut32 start_id, ut32 last_id)
RZ_API bool	rz_id_pool_grab_id (RzIDPool *pool, ut32 *grabber)
RZ_API bool	rz_id_pool_kick_id (RzIDPool *pool, ut32 kick)
RZ_API void	rz_id_pool_free (RzIDPool *pool)
RZ_API RzIDStorage *	rz_id_storage_new (ut32 start_id, ut32 last_id)
RZ_API bool	rz_id_storage_set (RzIDStorage *storage, void *data, ut32 id)
RZ_API bool	rz_id_storage_add (RzIDStorage *storage, void *data, ut32 *id)
RZ_API void *	rz_id_storage_get (RzIDStorage *storage, ut32 id)
RZ_API bool	rz_id_storage_get_next (RzIDStorage *storage, ut32 *id)
RZ_API bool	rz_id_storage_get_prev (RzIDStorage *storage, ut32 *id)
RZ_API void	rz_id_storage_delete (RzIDStorage *storage, ut32 id)
RZ_API void *	rz_id_storage_take (RzIDStorage *storage, ut32 id)
RZ_API bool	rz_id_storage_foreach (RzIDStorage *storage, RzIDStorageForeachCb cb, void *user)
RZ_API void	rz_id_storage_free (RzIDStorage *storage)
RZ_API RzList *	rz_id_storage_list (RzIDStorage *s)
RZ_API bool	rz_id_storage_get_lowest (RzIDStorage *storage, ut32 *id)
RZ_API bool	rz_id_storage_get_highest (RzIDStorage *storage, ut32 *id)
RZ_API ROIDStorage *	rz_oids_new (ut32 start_id, ut32 last_id)
RZ_API void *	rz_oids_get (ROIDStorage *storage, ut32 id)
RZ_API void *	rz_oids_oget (ROIDStorage *storage, ut32 od)
RZ_API bool	rz_oids_get_id (ROIDStorage *storage, ut32 od, ut32 *id)
RZ_API bool	rz_oids_get_od (ROIDStorage *storage, ut32 id, ut32 *od)
RZ_API bool	rz_oids_to_front (ROIDStorage *storage, const ut32 id)
RZ_API bool	rz_oids_to_rear (ROIDStorage *storage, const ut32 id)
RZ_API void	rz_oids_delete (ROIDStorage *storage, ut32 id)
RZ_API void	rz_oids_odelete (ROIDStorage *st, ut32 od)
RZ_API void	rz_oids_free (ROIDStorage *storage)
RZ_API bool	rz_oids_add (ROIDStorage *storage, void *data, ut32 *id, ut32 *od)
RZ_API void *	rz_oids_take (ROIDStorage *storage, ut32 id)
RZ_API void *	rz_oids_otake (ROIDStorage *st, ut32 od)
RZ_API bool	rz_oids_foreach (ROIDStorage *storage, RzIDStorageForeachCb cb, void *user)
RZ_API bool	rz_oids_foreach_prev (ROIDStorage *storage, RzIDStorageForeachCb cb, void *user)
RZ_API bool	rz_oids_insert (ROIDStorage *storage, void *data, ut32 *id, ut32 *od, void *user)
RZ_API bool	rz_oids_sort (ROIDStorage *storage, void *user)
RZ_API ut32	rz_oids_find (ROIDStorage *storage, void *incoming, void *user)
RZ_API void *	rz_oids_last (ROIDStorage *storage)
RZ_API void *	rz_oids_first (ROIDStorage *storage)

Typedef Documentation

ROIDStorage

typedef struct rz_ordered_id_storage_t ROIDStorage

ROIDStorageCompareCb

typedef bool(* ROIDStorageCompareCb) (void *in, void *incoming, void *user, int *cmp_res)

Definition at line 35 of file rz_idpool.h.

RzIDPool

typedef struct rz_id_pool_t RzIDPool

RzIDStorage

typedef struct rz_id_storage_t RzIDStorage

RzIDStorageForeachCb

typedef bool(* RzIDStorageForeachCb) (void *user, void *data, ut32 id)

Definition at line 34 of file rz_idpool.h.

Function Documentation

rz_id_pool_free()

RZ_API void rz_id_pool_free

(

RzIDPool *

pool

)

Definition at line 72 of file idpool.c.

                                            {
    if (!pool) {
        return;
    }
    rz_vector_free(pool->freed_ids);
    free(pool);
}

References free(), rz_id_pool_t::freed_ids, and rz_vector_free().

Referenced by rz_id_storage_delete(), rz_id_storage_free(), rz_id_storage_new(), rz_io_map_fini(), and rz_io_map_init().

rz_id_pool_grab_id()

RZ_API bool rz_id_pool_grab_id	(	RzIDPool *	pool,
		ut32 *	grabber
	)

Definition at line 34 of file idpool.c.

                                                              {
    rz_return_val_if_fail(pool && grabber, false);
 
    *grabber = UT32_MAX;
    if (pool->freed_ids) {
        rz_vector_pop_front(pool->freed_ids, grabber);
        if (rz_vector_empty(pool->freed_ids)) {
            RZ_FREE_CUSTOM(pool->freed_ids, rz_vector_free);
        }
        return true;
    }
    if (pool->next_id < pool->last_id) {
        *grabber = pool->next_id;
        pool->next_id++;
        return true;
    }
    return false;
}

References rz_id_pool_t::freed_ids, rz_id_pool_t::last_id, rz_id_pool_t::next_id, RZ_FREE_CUSTOM, rz_return_val_if_fail, rz_vector_empty(), rz_vector_free(), rz_vector_pop_front(), and UT32_MAX.

Referenced by io_map_new(), rz_bin_file_new(), rz_id_storage_add(), and rz_io_desc_new().

rz_id_pool_kick_id()

RZ_API bool rz_id_pool_kick_id	(	RzIDPool *	pool,
		ut32	kick
	)

Definition at line 53 of file idpool.c.

                                                          {
    if (!pool || (kick < pool->start_id) || (pool->start_id == pool->next_id)) {
        return false;
    }
    if (kick == (pool->next_id - 1)) {
        pool->next_id--;
        return true;
    }
    if (!pool->freed_ids) {
        pool->freed_ids = rz_vector_new(sizeof(ut32), NULL, NULL);
        if (!pool->freed_ids) {
            return false;
        }
        rz_vector_reserve(pool->freed_ids, 2);
    }
    rz_vector_push(pool->freed_ids, &kick);
    return true;
}

References rz_id_pool_t::freed_ids, rz_id_pool_t::next_id, NULL, rz_vector_new(), rz_vector_push(), rz_vector_reserve(), and rz_id_pool_t::start_id.

Referenced by map_del(), rz_bin_file_free(), and rz_id_storage_delete().

rz_id_pool_new()

RZ_API RzIDPool* rz_id_pool_new	(	ut32	start_id,
		ut32	last_id
	)

Definition at line 22 of file idpool.c.

                                                             {
    RzIDPool *pool = NULL;
    if (start_id < last_id) {
        pool = RZ_NEW0(RzIDPool);
        if (pool) {
            pool->next_id = pool->start_id = start_id;
            pool->last_id = last_id;
        }
    }
    return pool;
}

References rz_id_pool_t::last_id, rz_id_pool_t::next_id, NULL, RZ_NEW0, and rz_id_pool_t::start_id.

Referenced by rz_id_storage_delete(), rz_id_storage_new(), and rz_io_map_init().

rz_id_storage_add()

RZ_API bool rz_id_storage_add	(	RzIDStorage *	storage,
		void *	data,
		ut32 *	id
	)

Definition at line 155 of file idpool.c.

                                                                          {
    if (!storage || !rz_id_pool_grab_id(storage->pool, id)) {
        return false;
    }
    return rz_id_storage_set(storage, data, *id);
}

References rz_id_storage_t::pool, rz_id_pool_grab_id(), and rz_id_storage_set().

Referenced by parse_namemap(), rz_analysis_esil_load_source(), rz_oids_add(), and rz_oids_insert().

rz_id_storage_delete()

RZ_API void rz_id_storage_delete	(	RzIDStorage *	storage,
		ut32	id
	)

Definition at line 221 of file idpool.c.

                                                                {
    if (!storage || !storage->data || (storage->size <= id)) {
        return;
    }
    storage->data[id] = NULL;
    if (id == storage->top_id) {
        while (storage->top_id && !storage->data[storage->top_id]) {
            storage->top_id--;
        }
        if (!storage->top_id) {
            if (storage->data[storage->top_id]) {
                id_storage_reallocate(storage, 2);
            } else {
                RzIDPool *pool = rz_id_pool_new(storage->pool->start_id, storage->pool->last_id);
                RZ_FREE(storage->data);
                storage->size = 0;
                rz_id_pool_free(storage->pool);
                storage->pool = pool;
                return;
            }
        } else if ((storage->top_id + 1) < (storage->size / 4)) {
            id_storage_reallocate(storage, storage->size / 2);
        }
    }
    rz_id_pool_kick_id(storage->pool, id);
}

References rz_id_storage_t::data, id, id_storage_reallocate(), rz_id_pool_t::last_id, NULL, rz_id_storage_t::pool, RZ_FREE, rz_id_pool_free(), rz_id_pool_kick_id(), rz_id_pool_new(), rz_id_storage_t::size, rz_id_pool_t::start_id, and rz_id_storage_t::top_id.

Referenced by rz_analysis_esil_release_source(), rz_bin_file_close(), rz_id_storage_take(), rz_io_desc_free(), rz_oids_add(), rz_oids_delete(), and rz_oids_odelete().

rz_id_storage_foreach()

RZ_API bool rz_id_storage_foreach	(	RzIDStorage *	storage,
		RzIDStorageForeachCb	cb,
		void *	user
	)

Definition at line 254 of file idpool.c.

                                                                                             {
    ut32 i;
    if (!cb || !storage || !storage->data) {
        return false;
    }
    for (i = 0; i < storage->top_id; i++) {
        if (storage->data[i] && !cb(user, storage->data[i], i)) {
            return false;
        }
    }
    if (storage->data[i]) {
        return cb(user, storage->data[i], i);
    }
    return true;
}

References cb, rz_id_storage_t::data, i, and rz_id_storage_t::top_id.

Referenced by file_is_loaded(), rz_analysis_esil_sources_fini(), rz_core_bin_load(), rz_core_file_close_all_but(), rz_core_file_reopen_in_malloc(), rz_id_storage_list(), rz_io_desc_cache_fini_all(), rz_io_desc_fini(), rz_open_list_ascii_handler(), rz_open_list_handler(), and rz_serialize_io_files_save().

rz_id_storage_free()

RZ_API void rz_id_storage_free

(

RzIDStorage *

storage

)

Definition at line 270 of file idpool.c.

                                                     {
    if (storage) {
        rz_id_pool_free(storage->pool);
        free(storage->data);
    }
    free(storage);
}

References rz_id_storage_t::data, free(), rz_id_storage_t::pool, and rz_id_pool_free().

Referenced by parse_custom_name_entry(), rz_analysis_esil_sources_fini(), rz_bin_free(), rz_bin_new(), rz_bin_wasm_destroy(), rz_io_desc_fini(), and rz_oids_free().

rz_id_storage_get()

RZ_API void* rz_id_storage_get	(	RzIDStorage *	storage,
		ut32	id
	)

Definition at line 162 of file idpool.c.

                                                              {
    if (!storage || !storage->data || (storage->size <= id)) {
        return NULL;
    }
    return storage->data[id];
}

References rz_id_storage_t::data, id, NULL, and rz_id_storage_t::size.

Referenced by _get_source(), rz_bin_wasm_get_function_name(), rz_id_storage_take(), rz_io_desc_del(), rz_io_desc_get(), rz_io_desc_get_next(), rz_io_desc_get_prev(), rz_oids_get(), rz_oids_oget(), rz_oids_sort(), and rz_oids_take().

rz_id_storage_get_highest()

RZ_API bool rz_id_storage_get_highest	(	RzIDStorage *	storage,
		ut32 *	id
	)

Definition at line 178 of file idpool.c.

                                                                      {
    rz_return_val_if_fail(storage, false);
    size_t i = 0;
    if (storage->size > 0) {
        for (i = storage->size - 1; !storage->data[i] && i > 0; i--)
            ;
        *id = i;
        return storage->data[i] != NULL;
    }
    // *id = i;
    return false;
}

References rz_id_storage_t::data, i, NULL, rz_return_val_if_fail, and rz_id_storage_t::size.

Referenced by rz_io_fd_get_highest().

rz_id_storage_get_lowest()

RZ_API bool rz_id_storage_get_lowest	(	RzIDStorage *	storage,
		ut32 *	id
	)

Definition at line 169 of file idpool.c.

                                                                     {
    rz_return_val_if_fail(storage, false);
    ut32 i;
    for (i = 0; i < storage->size && !storage->data[i]; i++)
        ;
    *id = i;
    return i < storage->size;
}

References rz_id_storage_t::data, i, rz_return_val_if_fail, and rz_id_storage_t::size.

Referenced by rz_io_fd_get_lowest().

rz_id_storage_get_next()

RZ_API bool rz_id_storage_get_next	(	RzIDStorage *	storage,
		ut32 *	id
	)

Definition at line 191 of file idpool.c.

                                                                      {
    rz_return_val_if_fail(idref && storage, false);
    ut32 id = *idref;
    if (storage->size < 1 || id >= storage->size || !storage->data) {
        return false;
    }
    for (id = *idref + 1; id < storage->size && !storage->data[id]; id++)
        ;
    if (id < storage->size) {
        *idref = id;
        return true;
    }
    return false;
}

References rz_id_storage_t::data, id, rz_return_val_if_fail, and rz_id_storage_t::size.

Referenced by rz_io_fd_get_next().

rz_id_storage_get_prev()

RZ_API bool rz_id_storage_get_prev	(	RzIDStorage *	storage,
		ut32 *	id
	)

Definition at line 206 of file idpool.c.

                                                                      {
    rz_return_val_if_fail(idref && storage, false);
    ut32 id = *idref;
    if (id == 0 || id >= storage->size || storage->size < 1 || !storage->data) {
        return false;
    }
    for (id = *idref - 1; id > 0 && !storage->data[id]; id--)
        ;
    if (storage->data[id]) {
        *idref = id;
        return true;
    }
    return false;
}

References rz_id_storage_t::data, id, rz_return_val_if_fail, and rz_id_storage_t::size.

Referenced by rz_io_fd_get_prev().

rz_id_storage_list()

RZ_API RzList* rz_id_storage_list

(

RzIDStorage *

s

)

Definition at line 283 of file idpool.c.

                                                  { // remove this pls
    RzList *list = rz_list_newf(NULL);
    rz_id_storage_foreach(s, _list, list);
    return list;
}

References _list(), list(), NULL, rz_id_storage_foreach(), rz_list_newf(), and s.

Referenced by __file_history_down(), __file_history_up(), rz_core_vfile_bin_file_deleted(), and rz_open_binary_file_handler().

rz_id_storage_new()

RZ_API RzIDStorage* rz_id_storage_new	(	ut32	start_id,
		ut32	last_id
	)

Definition at line 80 of file idpool.c.

                                                                   {
    RzIDStorage *storage = NULL;
    RzIDPool *pool = rz_id_pool_new(start_id, last_id);
    if (pool) {
        storage = RZ_NEW0(RzIDStorage);
        if (!storage) {
            rz_id_pool_free(pool);
            return NULL;
        }
        storage->pool = pool;
    }
    return storage;
}

References NULL, rz_id_storage_t::pool, rz_id_pool_free(), rz_id_pool_new(), and RZ_NEW0.

Referenced by parse_custom_name_entry(), rz_analysis_esil_sources_init(), rz_bin_new(), rz_io_desc_init(), and rz_oids_new().

rz_id_storage_set()

RZ_API bool rz_id_storage_set	(	RzIDStorage *	storage,
		void *	data,
		ut32	id
	)

Definition at line 131 of file idpool.c.

                                                                         {
    ut32 n;
    if (!storage || !storage->pool || (id >= storage->pool->next_id)) {
        return false;
    }
    n = get_msb(id + 1);
    if (n > ((storage->size / 2) + (storage->size / 4))) {
        if ((n * 2) < storage->pool->last_id) {
            if (!id_storage_reallocate(storage, n * 2)) {
                return false;
            }
        } else if (n != (storage->pool->last_id)) {
            if (!id_storage_reallocate(storage, storage->pool->last_id)) {
                return false;
            }
        }
    }
    storage->data[id] = data;
    if (id > storage->top_id) {
        storage->top_id = id;
    }
    return true;
}

References rz_id_storage_t::data, get_msb(), id, id_storage_reallocate(), rz_id_pool_t::last_id, n, rz_id_pool_t::next_id, rz_id_storage_t::pool, rz_id_storage_t::size, and rz_id_storage_t::top_id.

Referenced by rz_bin_open_buf(), rz_id_storage_add(), rz_io_desc_add(), and rz_io_desc_exchange().

rz_id_storage_take()

RZ_API void* rz_id_storage_take	(	RzIDStorage *	storage,
		ut32	id
	)

Definition at line 248 of file idpool.c.

                                                               {
    void *ret = rz_id_storage_get(storage, id);
    rz_id_storage_delete(storage, id);
    return ret;
}

References rz_id_storage_delete(), and rz_id_storage_get().

Referenced by rz_bin_file_close().

rz_oids_add()

RZ_API bool rz_oids_add	(	ROIDStorage *	storage,
		void *	data,
		ut32 *	id,
		ut32 *	od
	)

Definition at line 336 of file idpool.c.

                                                                              {
    if (!storage || !id || !od) {
        return false;
    }
    if (!rz_id_storage_add(storage->data, data, id)) {
        return false;
    }
    if (!storage->permutation) {
        oid_storage_preallocate(storage, 4);
    } else if (storage->ptop > (storage->psize * 3 / 4)) {
        oid_storage_preallocate(storage, storage->psize * 2);
    }
    if (storage->psize <= storage->ptop) {
        rz_id_storage_delete(storage->data, *id);
        return false;
    }
    if (!storage->permutation) {
        return false;
    }
    *od = storage->ptop;
    storage->permutation[*od] = *id;
    storage->ptop++;
    return true;
}

References rz_ordered_id_storage_t::data, id, oid_storage_preallocate(), rz_ordered_id_storage_t::permutation, rz_ordered_id_storage_t::psize, rz_ordered_id_storage_t::ptop, rz_id_storage_add(), and rz_id_storage_delete().

Referenced by rz_oids_insert().

rz_oids_delete()

RZ_API void rz_oids_delete	(	ROIDStorage *	storage,
		ut32	id
	)

Definition at line 406 of file idpool.c.

                                                          {
    if (!rz_oids_to_front(storage, id)) {
        return;
    }
    rz_id_storage_delete(storage->data, id);
    storage->ptop--;
    if (!storage->ptop) {
        RZ_FREE(storage->permutation);
        storage->psize = 0;
    } else if ((storage->ptop + 1) < (storage->psize / 4)) {
        oid_storage_preallocate(storage, storage->psize / 2);
    }
}

References rz_ordered_id_storage_t::data, oid_storage_preallocate(), rz_ordered_id_storage_t::permutation, rz_ordered_id_storage_t::psize, rz_ordered_id_storage_t::ptop, RZ_FREE, rz_id_storage_delete(), and rz_oids_to_front().

Referenced by rz_oids_take().

rz_oids_find()

RZ_API ut32 rz_oids_find	(	ROIDStorage *	storage,
		void *	incoming,
		void *	user
	)

Definition at line 614 of file idpool.c.

                                                                           {
    ut32 ret;
    return oids_od_bfind(storage, &ret, incoming, user) ? ret : storage->ptop;
}

References oids_od_bfind(), and rz_ordered_id_storage_t::ptop.

rz_oids_first()

RZ_API void* rz_oids_first

(

ROIDStorage *

storage

)

Definition at line 467 of file idpool.c.

                                                 {
    if (storage && storage->data && storage->data->data && storage->permutation) {
        return storage->data->data[storage->permutation[storage->ptop - 1]];
    }
    return NULL;
}

References rz_id_storage_t::data, rz_ordered_id_storage_t::data, NULL, rz_ordered_id_storage_t::permutation, and rz_ordered_id_storage_t::ptop.

rz_oids_foreach()

RZ_API bool rz_oids_foreach	(	ROIDStorage *	storage,
		RzIDStorageForeachCb	cb,
		void *	user
	)

Definition at line 474 of file idpool.c.

                                                                                       {
    ut32 i;
    ut32 id;
    if (!cb || !storage || !storage->data || !storage->data->data || !storage->permutation) {
        return false;
    }
    for (i = storage->ptop - 1; i != 0; i--) {
        id = storage->permutation[i];
        if (!cb(user, storage->data->data[id], id)) {
            return false;
        }
    }
    id = storage->permutation[0];
    return cb(user, storage->data->data[id], id);
}

References cb, rz_id_storage_t::data, rz_ordered_id_storage_t::data, i, id, rz_ordered_id_storage_t::permutation, and rz_ordered_id_storage_t::ptop.

rz_oids_foreach_prev()

RZ_API bool rz_oids_foreach_prev	(	ROIDStorage *	storage,
		RzIDStorageForeachCb	cb,
		void *	user
	)

Definition at line 490 of file idpool.c.

                                                                                            {
    ut32 i;
    ut32 id;
    if (!cb || !storage || !storage->data || !storage->data->data || !storage->permutation) {
        return false;
    }
    for (i = 0; i < storage->ptop; i++) {
        id = storage->permutation[i];
        if (!cb(user, storage->data->data[id], id)) {
            return false;
        }
    }
    return true;
}

References cb, rz_id_storage_t::data, rz_ordered_id_storage_t::data, i, id, rz_ordered_id_storage_t::permutation, and rz_ordered_id_storage_t::ptop.

rz_oids_free()

RZ_API void rz_oids_free

(

ROIDStorage *

storage

)

Definition at line 450 of file idpool.c.

                                               {
    if (storage) {
        free(storage->permutation);
        rz_id_storage_free(storage->data);
    }
    free(storage);
}

References rz_ordered_id_storage_t::data, free(), rz_ordered_id_storage_t::permutation, and rz_id_storage_free().

rz_oids_get()

RZ_API void* rz_oids_get	(	ROIDStorage *	storage,
		ut32	id
	)

Definition at line 301 of file idpool.c.

                                                        {
    if (storage) {
        return rz_id_storage_get(storage->data, id);
    }
    return NULL;
}

References rz_ordered_id_storage_t::data, NULL, and rz_id_storage_get().

rz_oids_get_id()

RZ_API bool rz_oids_get_id	(	ROIDStorage *	storage,
		ut32	od,
		ut32 *	id
	)

Definition at line 316 of file idpool.c.

                                                                    {
    if (storage && storage->permutation && (storage->ptop > od)) {
        *id = storage->permutation[od];
        return true;
    }
    return false;
}

References rz_ordered_id_storage_t::permutation, and rz_ordered_id_storage_t::ptop.

Referenced by rz_oids_oget().

rz_oids_get_od()

RZ_API bool rz_oids_get_od	(	ROIDStorage *	storage,
		ut32	id,
		ut32 *	od
	)

Definition at line 324 of file idpool.c.

                                                                    {
    if (storage && storage->permutation &&
        storage->data && (id < storage->data->pool->next_id)) {
        for (od[0] = 0; od[0] < storage->ptop; od[0]++) {
            if (id == storage->permutation[od[0]]) {
                return true;
            }
        }
    }
    return false;
}

References rz_ordered_id_storage_t::data, rz_ordered_id_storage_t::permutation, and rz_ordered_id_storage_t::ptop.

rz_oids_insert()

RZ_API bool rz_oids_insert	(	ROIDStorage *	storage,
		void *	data,
		ut32 *	id,
		ut32 *	od,
		void *	user
	)

Definition at line 563 of file idpool.c.

                                                                                             {
    if (!storage || !storage->cmp || !id || !od) {
        return false;
    }
    if (!storage->ptop) { // empty storage
        return rz_oids_add(storage, data, id, od);
    }
    if (!rz_id_storage_add(storage->data, data, id)) {
        return false;
    }
    if (storage->ptop > (storage->psize * 3 / 4)) {
        oid_storage_preallocate(storage, storage->psize * 2);
    }
    return oids_od_binsert(storage, id[0], od, data, user);
}

References rz_ordered_id_storage_t::cmp, rz_ordered_id_storage_t::data, oid_storage_preallocate(), oids_od_binsert(), rz_ordered_id_storage_t::psize, rz_ordered_id_storage_t::ptop, rz_id_storage_add(), and rz_oids_add().

rz_oids_last()

RZ_API void* rz_oids_last

(

ROIDStorage *

storage

)

Definition at line 459 of file idpool.c.

                                                {
    if (storage && storage->data && storage->data->data && storage->permutation) {
        return storage->data->data[storage->permutation[0]];
    }
    return NULL;
}

References rz_id_storage_t::data, rz_ordered_id_storage_t::data, NULL, and rz_ordered_id_storage_t::permutation.

rz_oids_new()

RZ_API ROIDStorage* rz_oids_new	(	ut32	start_id,
		ut32	last_id
	)

Definition at line 289 of file idpool.c.

                                                             {
    ROIDStorage *storage = RZ_NEW0(ROIDStorage);
    if (!storage) {
        return NULL;
    }
    if (!(storage->data = rz_id_storage_new(start_id, last_id))) {
        free(storage);
        return NULL;
    }
    return storage;
}

References rz_ordered_id_storage_t::data, free(), NULL, rz_id_storage_new(), and RZ_NEW0.

rz_oids_odelete()

RZ_API void rz_oids_odelete	(	ROIDStorage *	st,
		ut32	od
	)

Definition at line 420 of file idpool.c.

                                                      {
    ut32 n;
    if (!st || !st->permutation || od >= st->ptop) {
        return;
    }
    n = st->ptop - od - 1;
    rz_id_storage_delete(st->data, st->permutation[od]);
    memmove(&st->permutation[od], &st->permutation[od + 1], n * sizeof(ut32));
    st->ptop--;
    if (!st->ptop) {
        RZ_FREE(st->permutation);
        st->psize = 0;
    } else if ((st->ptop + 1) < (st->psize / 4)) {
        oid_storage_preallocate(st, st->psize / 2);
    }
}

References rz_ordered_id_storage_t::data, n, oid_storage_preallocate(), rz_ordered_id_storage_t::permutation, rz_ordered_id_storage_t::psize, rz_ordered_id_storage_t::ptop, RZ_FREE, and rz_id_storage_delete().

Referenced by rz_oids_otake().

rz_oids_oget()

RZ_API void* rz_oids_oget	(	ROIDStorage *	storage,
		ut32	od
	)

Definition at line 308 of file idpool.c.

                                                         {
    ut32 id;
    if (rz_oids_get_id(storage, od, &id)) {
        return rz_id_storage_get(storage->data, id);
    }
    return NULL;
}

References rz_ordered_id_storage_t::data, id, NULL, rz_id_storage_get(), and rz_oids_get_id().

Referenced by oids_od_bfind(), and rz_oids_otake().

rz_oids_otake()

RZ_API void* rz_oids_otake	(	ROIDStorage *	st,
		ut32	od
	)

Definition at line 444 of file idpool.c.

                                                     {
    void *ret = rz_oids_oget(st, od);
    rz_oids_odelete(st, od);
    return ret;
}

References rz_oids_odelete(), and rz_oids_oget().

rz_oids_sort()

RZ_API bool rz_oids_sort	(	ROIDStorage *	storage,
		void *	user
	)

Definition at line 579 of file idpool.c.

                                                           {
    ut32 od, id, ptop, *permutation;
 
    if (!storage || !storage->ptop || !storage->cmp) {
        return false;
    }
    if (storage->ptop == 1) {
        return true;
    }
    permutation = storage->permutation;
    storage->permutation = RZ_NEWS0(ut32, storage->psize);
    if (!storage->permutation) {
        storage->permutation = permutation;
        return false;
    }
    storage->permutation[0] = permutation[0];
    ptop = storage->ptop;
    storage->ptop = 1;
    while (storage->ptop != ptop) {
        id = permutation[storage->ptop];
        void *incoming = rz_id_storage_get(storage->data, id);
        if (!oids_od_binsert(storage, id, &od, incoming, user)) {
            goto beach;
        }
    }
    free(permutation);
    return true;
 
beach:
    free(storage->permutation);
    storage->permutation = permutation;
    storage->ptop = ptop;
    return false;
}

References rz_ordered_id_storage_t::cmp, rz_ordered_id_storage_t::data, free(), id, oids_od_binsert(), rz_ordered_id_storage_t::permutation, rz_ordered_id_storage_t::psize, rz_ordered_id_storage_t::ptop, rz_id_storage_get(), and RZ_NEWS0.

rz_oids_take()

RZ_API void* rz_oids_take	(	ROIDStorage *	storage,
		ut32	id
	)

Definition at line 437 of file idpool.c.

                                                         {
    rz_return_val_if_fail(storage, NULL);
    void *ret = rz_id_storage_get(storage->data, id);
    rz_oids_delete(storage, id);
    return ret;
}

References rz_ordered_id_storage_t::data, NULL, rz_id_storage_get(), rz_oids_delete(), and rz_return_val_if_fail.

rz_oids_to_front()

RZ_API bool rz_oids_to_front	(	ROIDStorage *	storage,
		const ut32	id
	)

Definition at line 361 of file idpool.c.

                                                                  {
    ut32 od;
    if (!storage || !storage->permutation) {
        return false;
    }
    for (od = 0; od < storage->ptop; od++) {
        if (id == storage->permutation[od]) {
            break;
        }
    }
    if (od == storage->ptop) {
        return false;
    } else if (od == (storage->ptop - 1)) {
        return true;
    }
    memmove(&storage->permutation[od], &storage->permutation[od + 1],
        (storage->ptop - od - 1) * sizeof(ut32));
    storage->permutation[storage->ptop - 1] = id;
    return true;
}

References id, rz_ordered_id_storage_t::permutation, and rz_ordered_id_storage_t::ptop.

Referenced by rz_oids_delete().

rz_oids_to_rear()

RZ_API bool rz_oids_to_rear	(	ROIDStorage *	storage,
		const ut32	id
	)

Definition at line 382 of file idpool.c.

                                                           {
    ut32 od;
    if (!storage || !storage->permutation ||
        !storage->data || (id >= storage->data->pool->next_id)) {
        return false;
    }
    bool found = false;
    for (od = 0; od < storage->ptop; od++) {
        if (id == storage->permutation[od]) {
            found = true;
            break;
        }
    }
    if (od == storage->ptop) {
        return false;
    }
    if (!found) {
        return true;
    }
    memmove(&storage->permutation[1], &storage->permutation[0], od * sizeof(ut32));
    storage->permutation[0] = id;
    return true;
}

References rz_ordered_id_storage_t::data, found, id, rz_id_pool_t::next_id, rz_ordered_id_storage_t::permutation, rz_id_storage_t::pool, and rz_ordered_id_storage_t::ptop.