struct list_elem
*list_prev(struct list_elem *e)
{
assert(e);
assert(is_interior(e) || is_tail(e));
return e->prev;
}
struct list_elem *
list_next (struct list_elem *elem)
{
ASSERT (is_head (elem) == true || is_interior (elem) == true);
return elem->next;
}
struct list_elem
*list_next(struct list_elem *e)
{
assert(e);
assert(is_head(e) || is_interior(e));
return e->next;
}
/* Removes ELEM from its list and returns the element that
followed it. Undefined behavior if ELEM is not in a list.
A list element must be treated very carefully after removing
it from its list. Calling list_next() or list_prev() on ELEM
will return the item that was previously before or after ELEM,
but, e.g., list_prev(list_next(ELEM)) is no longer ELEM!
The list_remove() return value provides a convenient way to
iterate and remove elements from a list:
for (e = list_begin (&list); e != list_end (&list); e = list_remove (e))
{
...do something with e...
}
If you need to free() elements of the list then you need to be
more conservative. Here's an alternate strategy that works
even in that case:
while (!list_empty (&list))
{
struct list_elem *e = list_pop_front (&list);
...do something with e...
}
*/
struct list_elem *
list_remove (struct list_elem *elem)
{
ASSERT (is_interior (elem));
elem->prev->next = elem->next;
elem->next->prev = elem->prev;
return elem->next;
}
struct list_elem*
list_remove(struct list_elem *e)
{
assert(e);
assert(is_interior(e));
e->prev->next = e->next;
e->next->prev = e->prev;
return e->next;
}
/* Inserts ELEM just before BEFORE, which may be either an
interior element or a tail. The latter case is equivalent to
list_push_back(). */
void
list_insert (struct list_elem *before, struct list_elem *elem)
{
ASSERT (is_interior (before) || is_tail (before));
ASSERT (elem != NULL);
elem->prev = before->prev;
elem->next = before;
before->prev->next = elem;
before->prev = elem;
}
/*
* Removes ELEM from its list and returns the element that
* followed it. Undefined behavior if ELEM is not in a list.
*/
struct list_elem *
list_remove (struct list_elem *elem)
{
struct list_elem *next = elem->next;
ASSERT (is_interior (elem));
elem->prev->next = elem->next;
elem->next->prev = elem->prev;
elem->next = elem->prev = NULL; /* be safe; dump if your not */
return next;
}
void
list_insert (struct list_elem *before, struct list_elem *elem)
{
ASSERT (is_interior (before) == true || is_tail (before) == true);
ASSERT (NULL != elem);
elem->prev = before->prev;
elem->next = before;
before->prev->next = elem;
before->prev = elem;
}
/* Removes elements FIRST though LAST (exclusive) from their
current list, then inserts them just before BEFORE, which may
be either an interior element or a tail. */
void
list_splice (struct list_elem *before,
struct list_elem *first, struct list_elem *last)
{
ASSERT (is_interior (before) || is_tail (before));
if (first == last)
return;
last = list_prev (last);
ASSERT (is_interior (first));
ASSERT (is_interior (last));
/* Cleanly remove FIRST...LAST from its current list. */
first->prev->next = last->next;
last->next->prev = first->prev;
/* Splice FIRST...LAST into new list. */
first->prev = before->prev;
last->next = before;
before->prev->next = first;
before->prev = last;
}
/* Inserts ELEM just before BEFORE, which may be either an
interior element or a tail. The latter case is equivalent to
list_push_back(). */
void
list_insert (struct list_elem *before, struct list_elem *elem)
{
ASSERT (is_interior (before) || is_tail (before));
ASSERT (elem != NULL);
/* Abraham driving */
//elem->node_lock = before->node_lock; /* gave a copy of the lock to the new element we just added */
elem->prev = before->prev;
elem->next = before;
before->prev->next = elem;
before->prev = elem;
}
/* Returns the element before ELEM in its list. If ELEM is the
first element in its list, returns the list head. Results are
undefined if ELEM is itself a list head. */
struct list_elem *
list_prev (struct list_elem *elem)
{
ASSERT (is_interior (elem) || is_tail (elem));
return elem->prev;
}
/* Returns the element after ELEM in its list. If ELEM is the
last element in its list, returns the list tail. Results are
undefined if ELEM is itself a list tail. */
struct list_elem *
list_next (struct list_elem *elem)
{
assert (is_head (elem) || is_interior (elem));
return elem->next;
}
