int list_delete_all(List l, ListFindF f, void *key)
{
ListNode *pp;
void *v;
int n = 0;
assert(l != NULL);
assert(f != NULL);
assert(key != NULL);
list_mutex_lock(&l->mutex);
assert(l->magic == LIST_MAGIC);
pp = &l->head;
while (*pp) {
if (f((*pp)->data, key)) {
if ((v = list_node_destroy(l, pp))) {
if (l->fDel)
l->fDel(v);
n++;
}
}
else {
pp = &(*pp)->next;
}
}
list_mutex_unlock(&l->mutex);
return(n);
}
/* _list_pop_locked
*
* Pop an item from the list assuming the
* the list is already locked.
*/
static void *
_list_pop_locked(List l)
{
void *v;
v = list_node_destroy(l, &l->head);
return v;
}
void list_destroy(list_t *list) {
list_node_t *temp;
for (list_node_t *node = list->head; node; ) {
temp = node->next;
list_node_destroy(node);
node = temp;
}
list_atcache_destroy(list);
free(list);
}
void * list_dequeue(List l)
{
void *v;
assert(l != NULL);
list_mutex_lock(&l->mutex);
assert(l->magic == LIST_MAGIC);
v = list_node_destroy(l, &l->head);
list_mutex_unlock(&l->mutex);
return(v);
}
void *list_pop(llist *l)
{
void *data = NULL;
list_node *tmp_node = NULL;
if (l) {
tmp_node = l->node;
data = tmp_node->data;
l->node = tmp_node->next;
list_node_destroy(tmp_node);
}
return data;
}
/* Removes a node from the list
* Arguments: The list and the node that will be removed
*/
void list_remove(llist *l, list_node *node)
{
if (!l || !node) return;
list_node *tmp = l->node;
while (tmp->next && tmp->next != node) tmp = tmp->next;
if (tmp->next) {
tmp->next = node->next;
list_node_destroy(node);
node = NULL;
}
}
void * list_remove(ListIterator i)
{
void *v = NULL;
assert(i != NULL);
assert(i->magic == LIST_MAGIC);
list_mutex_lock(&i->list->mutex);
assert(i->list->magic == LIST_MAGIC);
if (*i->prev != i->pos)
v = list_node_destroy(i->list, i->prev);
list_mutex_unlock(&i->list->mutex);
return(v);
}
void
list_destroy(TinyList *thiz) {
TinyListNode *iter = thiz->first;
TinyListNode *next = NULL;
while(iter != NULL) {
next = iter->next;
list_node_destroy(iter);
iter = next;
}
thiz->first = NULL;
free(thiz);
return;
}
void list_destroy(list *ls)
{
node *curr, *next;
curr = ls->head;
while (curr)
{
next = curr->next;
list_node_destroy(curr, ls->free_func);
curr = next;
}
free(ls);
}
void list_clear(t_list *list)
{
t_list_node *it;
t_list_node *next;
it = list->first;
next = NULL;
while (it)
{
next = it->next;
list_node_destroy(it, list->dfunc);
free(it);
it = next;
}
list->first = NULL;
list->last = NULL;
}
ListRet
list_delete(TinyList *thiz, size_t index) {
TinyListNode *cursor = list_get_node(thiz, index, 0);
if(cursor != NULL) {
if(cursor == thiz->first) {
thiz->first = cursor->next;
}
if(cursor->next != NULL) {
cursor->next->prev = cursor->prev;
}
if(cursor->prev != NULL) {
cursor->prev->next = cursor->next;
}
list_node_destroy(cursor);
}
return LIST_RET_OK;
}
void list_remove(list *ls, int index)
{
int count = 0;
node *curr, *next;
curr = ls->head;
next = curr->next;
while (count < index)
{
if (count++ > ls->length) return; // End function
curr = next;
next = curr->next;
}
// Update pointer and delete orphan
curr->next = next->next;
list_node_destroy(next, ls->free_func);
}
t_list_node *list_erase(t_list *list, t_list_node *node)
{
t_list_node *next;
t_list_node *prev;
if (node == NULL)
return (NULL);
next = node->next;
prev = node->prev;
if (next)
next->prev = prev;
if (prev)
prev->next = next;
if (node == list->first)
list->first = next;
if (node == list->first)
list->last = prev;
list_node_destroy(node, list->dfunc);
free(node);
return (next);
}
bool list_erase(list_t *list, void *element) {
for (list_node_t *curr = list->head; curr; curr = curr->next) {
if (curr->element != element)
continue;
if (curr == list->head)
list->head = list->head->next;
if (curr == list->tail)
list->tail = list->tail->prev;
if (curr->next)
curr->next->prev = curr->prev;
if (curr->prev)
curr->prev->next = curr->next;
list_node_destroy(curr);
list->length--;
list_atcache_thrash(list);
return true;
}
return false;
}
/* list_flush()
*/
int
list_flush (List l)
{
ListNode *pp;
void *v;
int n = 0;
assert(l != NULL);
slurm_mutex_lock(&l->mutex);
assert(l->magic == LIST_MAGIC);
pp = &l->head;
while (*pp) {
if ((v = list_node_destroy(l, pp))) {
if (l->fDel)
l->fDel(v);
n++;
}
}
slurm_mutex_unlock(&l->mutex);
return n;
}
static void list_node_scrub(list_node_t **node) {
list_node_destroy(*node);
*node = NULL;
}
