Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/include/adt/list.h

    rb72efe8 r0a02653  
    11/*
    22 * Copyright (c) 2001-2004 Jakub Jermar
    3  * Copyright (c) 2011 Jiri Svoboda
    43 * All rights reserved.
    54 *
    … …  
    3736#define LIBC_LIST_H_
    3837
    39 #include <assert.h>
    4038#include <unistd.h>
    4139
    42 /** Doubly linked list link. */
     40/** Doubly linked list head and link type. */
    4341typedef struct link {
    4442        struct link *prev;  /**< Pointer to the previous item in the list. */
    … …  
    4644} link_t;
    4745
    48 /** Doubly linked list. */
    49 typedef struct list {
    50         link_t head;  /**< List head. Does not have any data. */
    51 } list_t;
    52 
    5346/** Declare and initialize statically allocated list.
    5447 *
    … …  
    5750 */
    5851#define LIST_INITIALIZE(name) \
    59         list_t name = { \
    60                 .head = { \
    61                         .prev = &(name).head, \
    62                         .next = &(name).head \
    63                 } \
     52        link_t name = { \
     53                .prev = &name, \
     54                .next = &name \
    6455        }
    6556
    … …  
    6859
    6960#define list_foreach(list, iterator) \
    70         for (link_t *iterator = (list).head.next; \
    71             iterator != &(list).head; iterator = iterator->next)
    72 
    73 #define assert_link_not_used(link) \
    74         assert((link)->prev == NULL && (link)->next == NULL)
     61        for (link_t *iterator = (list).next; \
     62            iterator != &(list); iterator = iterator->next)
    7563
    7664/** Initialize doubly-linked circular list link
    … …  
    9179 * Initialize doubly-linked circular list.
    9280 *
    93  * @param list Pointer to list_t structure.
    94  *
    95  */
    96 static inline void list_initialize(list_t *list)
    97 {
    98         list->head.prev = &list->head;
    99         list->head.next = &list->head;
     81 * @param list Pointer to link_t structure representing the list.
     82 *
     83 */
     84static inline void list_initialize(link_t *list)
     85{
     86        list->prev = list;
     87        list->next = list;
     88}
     89
     90/** Add item to the beginning of doubly-linked circular list
     91 *
     92 * Add item to the beginning of doubly-linked circular list.
     93 *
     94 * @param link Pointer to link_t structure to be added.
     95 * @param list Pointer to link_t structure representing the list.
     96 *
     97 */
     98static inline void list_prepend(link_t *link, link_t *list)
     99{
     100        link->next = list->next;
     101        link->prev = list;
     102        list->next->prev = link;
     103        list->next = link;
     104}
     105
     106/** Add item to the end of doubly-linked circular list
     107 *
     108 * Add item to the end of doubly-linked circular list.
     109 *
     110 * @param link Pointer to link_t structure to be added.
     111 * @param list Pointer to link_t structure representing the list.
     112 *
     113 */
     114static inline void list_append(link_t *link, link_t *list)
     115{
     116        link->prev = list->prev;
     117        link->next = list;
     118        list->prev->next = link;
     119        list->prev = link;
    100120}
    101121
    … …  
    103123 *
    104124 */
    105 static inline void list_insert_before(link_t *lnew, link_t *lold)
    106 {
    107         lnew->next = lold;
    108         lnew->prev = lold->prev;
    109         lold->prev->next = lnew;
    110         lold->prev = lnew;
     125static inline void list_insert_before(link_t *link, link_t *list)
     126{
     127        list_append(link, list);
    111128}
    112129
    … …  
    114131 *
    115132 */
    116 static inline void list_insert_after(link_t *lnew, link_t *lold)
    117 {
    118         lnew->prev = lold;
    119         lnew->next = lold->next;
    120         lold->next->prev = lnew;
    121         lold->next = lnew;
    122 }
    123 
    124 /** Add item to the beginning of doubly-linked circular list
    125  *
    126  * Add item to the beginning of doubly-linked circular list.
    127  *
    128  * @param link Pointer to link_t structure to be added.
    129  * @param list Pointer to list_t structure.
    130  *
    131  */
    132 static inline void list_prepend(link_t *link, list_t *list)
    133 {
    134         list_insert_after(link, &list->head);
    135 }
    136 
    137 /** Add item to the end of doubly-linked circular list
    138  *
    139  * Add item to the end of doubly-linked circular list.
    140  *
    141  * @param link Pointer to link_t structure to be added.
    142  * @param list Pointer to list_t structure.
    143  *
    144  */
    145 static inline void list_append(link_t *link, list_t *list)
    146 {
    147         list_insert_before(link, &list->head);
     133static inline void list_insert_after(link_t *link, link_t *list)
     134{
     135        list_prepend(list, link);
    148136}
    149137
    … …  
    167155 * Query emptiness of doubly-linked circular list.
    168156 *
    169  * @param list Pointer to lins_t structure.
    170  *
    171  */
    172 static inline int list_empty(list_t *list)
    173 {
    174         return (list->head.next == &list->head);
    175 }
    176 
    177 /** Get first item in list.
    178  *
    179  * @param list Pointer to list_t structure.
     157 * @param list Pointer to link_t structure representing the list.
     158 *
     159 */
     160static inline int list_empty(link_t *list)
     161{
     162        return (list->next == list);
     163}
     164
     165/** Get head item of a list.
     166 *
     167 * @param list Pointer to link_t structure representing the list.
    180168 *
    181169 * @return Head item of the list.
    … …  
    183171 *
    184172 */
    185 static inline link_t *list_first(list_t *list)
    186 {
    187         return ((list->head.next == &list->head) ? NULL : list->head.next);
    188 }
    189 
    190 /** Get last item in list.
    191  *
    192  * @param list Pointer to list_t structure.
    193  *
    194  * @return Head item of the list.
    195  * @return NULL if the list is empty.
    196  *
    197  */
    198 static inline link_t *list_last(list_t *list)
    199 {
    200         return ((list->head.prev == &list->head) ? NULL : list->head.prev);
     173static inline link_t *list_head(link_t *list)
     174{
     175        return ((list->next == list) ? NULL : list->next);
    201176}
    202177
    … …  
    255230}
    256231
    257 /** Get n-th item in a list.
     232/** Get n-th item of a list.
    258233 *
    259234 * @param list Pointer to link_t structure representing the list.
    … …  
    264239 *
    265240 */
    266 static inline link_t *list_nth(list_t *list, unsigned int n)
     241static inline link_t *list_nth(link_t *list, unsigned int n)
    267242{
    268243        unsigned int cnt = 0;
    … …  
    278253}
    279254
    280 extern int list_member(const link_t *, const list_t *);
    281 extern void list_concat(list_t *, list_t *);
    282 extern unsigned int list_count(const list_t *);
     255extern int list_member(const link_t *, const link_t *);
     256extern void list_concat(link_t *, link_t *);
     257extern unsigned int list_count(const link_t *);
    283258
    284259#endif
Note: See TracChangeset for help on using the changeset viewer.