[mirror_frr.git] / lib / linklist.h

/* Generic linked list
 * Copyright (C) 1997, 2000 Kunihiro Ishiguro
 *
 * This file is part of GNU Zebra.
 *
 * GNU Zebra is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2, or (at your option) any
 * later version.
 *
 * GNU Zebra is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; see the file COPYING; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 */

#ifndef _ZEBRA_LINKLIST_H
#define _ZEBRA_LINKLIST_H

#ifdef __cplusplus
extern "C" {
#endif

/* listnodes must always contain data to be valid. Adding an empty node
 * to a list is invalid
 */
struct listnode {
	struct listnode *next;
	struct listnode *prev;

	/* private member, use getdata() to retrieve, do not access directly */
	void *data;
};

struct list {
	struct listnode *head;
	struct listnode *tail;

	/* invariant: count is the number of listnodes in the list */
	unsigned int count;

	/*
	 * Returns -1 if val1 < val2, 0 if equal?, 1 if val1 > val2.
	 * Used as definition of sorted for listnode_add_sort
	 */
	int (*cmp)(void *val1, void *val2);

	/* callback to free user-owned data when listnode is deleted. supplying
	 * this callback is very much encouraged!
	 */
	void (*del)(void *val);
};

#define listnextnode(X) ((X) ? ((X)->next) : NULL)
#define listnextnode_unchecked(X) ((X)->next)
#define listhead(X) ((X) ? ((X)->head) : NULL)
#define listhead_unchecked(X) ((X)->head)
#define listtail(X) ((X) ? ((X)->tail) : NULL)
#define listcount(X) ((X)->count)
#define list_isempty(X) ((X)->head == NULL && (X)->tail == NULL)
/* return X->data only if X and X->data are not NULL */
#define listgetdata(X) (assert(X), assert((X)->data != NULL), (X)->data)

/*
 * Create a new linked list.
 *
 * Returns:
 *    the created linked list
 */
extern struct list *list_new(void);

/*
 * Add a new element to the tail of a list.
 *
 * Runtime is O(1).
 *
 * list
 *    list to operate on
 *
 * data
 *    element to add
 */
extern void listnode_add(struct list *list, void *data);

/*
 * Add a new element to the beginning of a list.
 *
 * Runtime is O(1).
 *
 * list
 *    list to operate on
 *
 * data
 *    element to add
 */
extern void listnode_add_head(struct list *list, void *data);

/*
 * Insert a new element into a list with insertion sort.
 *
 * If list->cmp is set, this function is used to determine the position to
 * insert the new element. If it is not set, this function is equivalent to
 * listnode_add.
 *
 * Runtime is O(N).
 *
 * list
 *    list to operate on
 *
 * val
 *    element to add
 */
extern void listnode_add_sort(struct list *list, void *val);

/*
 * Insert a new element into a list after another element.
 *
 * Runtime is O(1).
 *
 * list
 *    list to operate on
 *
 * pp
 *    listnode to insert after
 *
 * data
 *    data to insert
 *
 * Returns:
 *    pointer to newly created listnode that contains the inserted data
 */
extern struct listnode *listnode_add_after(struct list *list,
					   struct listnode *pp, void *data);

/*
 * Insert a new element into a list before another element.
 *
 * Runtime is O(1).
 *
 * list
 *    list to operate on
 *
 * pp
 *    listnode to insert before
 *
 * data
 *    data to insert
 *
 * Returns:
 *    pointer to newly created listnode that contains the inserted data
 */
extern struct listnode *listnode_add_before(struct list *list,
					    struct listnode *pp, void *data);

/*
 * Move a node to the tail of a list.
 *
 * Runtime is O(1).
 *
 * list
 *    list to operate on
 *
 * node
 *    node to move to tail
 */
extern void listnode_move_to_tail(struct list *list, struct listnode *node);

/*
 * Delete an element from a list.
 *
 * Runtime is O(N).
 *
 * list
 *    list to operate on
 *
 * data
 *    data to insert into list
 */
extern void listnode_delete(struct list *list, void *data);

/*
 * Find the listnode corresponding to an element in a list.
 *
 * list
 *    list to operate on
 *
 * data
 *    data to search for
 *
 * Returns:
 *    pointer to listnode storing the given data if found, NULL otherwise
 */
extern struct listnode *listnode_lookup(struct list *list, void *data);

/*
 * Retrieve the element at the head of a list.
 *
 * list
 *    list to operate on
 *
 * Returns:
 *    data at head of list, or NULL if list is empty
 */
extern void *listnode_head(struct list *list);

/*
 * Duplicate a list.
 *
 * list
 *    list to duplicate
 *
 * Returns:
 *    copy of the list
 */
extern struct list *list_dup(struct list *l);

/*
 * Sort a list in place.
 *
 * The sorting algorithm used is quicksort. Runtimes are equivalent to those of
 * quicksort plus N. The sort is not stable.
 *
 * For portability reasons, the comparison function takes a pointer to pointer
 * to void. This pointer should be dereferenced to get the actual data pointer.
 * It is always safe to do this.
 *
 * list
 *    list to sort
 *
 * cmp
 *    comparison function for quicksort. Should return less than, equal to or
 *    greater than zero if the first argument is less than, equal to or greater
 *    than the second argument.
 */
extern void list_sort(struct list *list,
		      int (*cmp)(const void **, const void **));

/*
 * Delete a list and NULL its pointer.
 *
 * If non-null, list->del is called with each data element.
 *
 * plist
 *    pointer to list pointer; this will be set to NULL after the list has been
 *    deleted
 */
extern void list_delete(struct list **plist);

/*
 * Delete all nodes from a list without deleting the list itself.
 *
 * If non-null, list->del is called with each data element.
 *
 * list
 *    list to operate on
 */
extern void list_delete_all_node(struct list *list);

/*
 * Delete a node from a list.
 *
 * list->del is not called with the data associated with the node.
 *
 * Runtime is O(1).
 *
 * list
 *    list to operate on
 *
 * node
 *    the node to delete
 */
extern void list_delete_node(struct list *list, struct listnode *node);

/*
 * Append a list to an existing list.
 *
 * Runtime is O(N) where N = listcount(add).
 *
 * list
 *    list to append to
 *
 * add
 *    list to append
 */
extern void list_add_list(struct list *list, struct list *add);

/* List iteration macro.
 * Usage: for (ALL_LIST_ELEMENTS (...) { ... }
 * It is safe to delete the listnode using this macro.
 */
#define ALL_LIST_ELEMENTS(list, node, nextnode, data)                          \
	(node) = listhead(list), ((data) = NULL);                              \
	(node) != NULL                                                         \
		&& ((data) = static_cast(data, listgetdata(node)),             \
		    (nextnode) = node->next, 1);                               \
	(node) = (nextnode), ((data) = NULL)

/* read-only list iteration macro.
 * Usage: as per ALL_LIST_ELEMENTS, but not safe to delete the listnode Only
 * use this macro when it is *immediately obvious* the listnode is not
 * deleted in the body of the loop. Does not have forward-reference overhead
 * of previous macro.
 */
#define ALL_LIST_ELEMENTS_RO(list, node, data)                                 \
	(node) = listhead(list), ((data) = NULL);                              \
	(node) != NULL && ((data) = static_cast(data, listgetdata(node)), 1);  \
	(node) = listnextnode(node), ((data) = NULL)

/* these *do not* cleanup list nodes and referenced data, as the functions
 * do - these macros simply {de,at}tach a listnode from/to a list.
 */

/* List node attach macro.  */
#define LISTNODE_ATTACH(L, N)                                                  \
	do {                                                                   \
		(N)->prev = (L)->tail;                                         \
		(N)->next = NULL;                                              \
		if ((L)->head == NULL)                                         \
			(L)->head = (N);                                       \
		else                                                           \
			(L)->tail->next = (N);                                 \
		(L)->tail = (N);                                               \
		(L)->count++;                                                  \
	} while (0)

/* List node detach macro.  */
#define LISTNODE_DETACH(L, N)                                                  \
	do {                                                                   \
		if ((N)->prev)                                                 \
			(N)->prev->next = (N)->next;                           \
		else                                                           \
			(L)->head = (N)->next;                                 \
		if ((N)->next)                                                 \
			(N)->next->prev = (N)->prev;                           \
		else                                                           \
			(L)->tail = (N)->prev;                                 \
		(L)->count--;                                                  \
	} while (0)

extern struct listnode *listnode_lookup_nocheck(struct list *list, void *data);

#ifdef __cplusplus
}
#endif

#endif /* _ZEBRA_LINKLIST_H */
Commit	Line	Data
718e3744	1	/* Generic linked list
	2	* Copyright (C) 1997, 2000 Kunihiro Ishiguro
	3	*
	4	* This file is part of GNU Zebra.
	5	*
	6	* GNU Zebra is free software; you can redistribute it and/or modify it
	7	* under the terms of the GNU General Public License as published by the
	8	* Free Software Foundation; either version 2, or (at your option) any
	9	* later version.
	10	*
	11	* GNU Zebra is distributed in the hope that it will be useful, but
	12	* WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	* General Public License for more details.
	15	*
896014f4 DL	16	* You should have received a copy of the GNU General Public License along
	17	* with this program; see the file COPYING; if not, write to the Free Software
	18	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
718e3744	19	*/
	20
	21	#ifndef _ZEBRA_LINKLIST_H
	22	#define _ZEBRA_LINKLIST_H
	23
5e244469 RW	24	#ifdef __cplusplus
	25	extern "C" {
	26	#endif
	27
1eb8ef25	28	/* listnodes must always contain data to be valid. Adding an empty node
	29	* to a list is invalid
	30	*/
d62a17ae	31	struct listnode {
	32	struct listnode *next;
	33	struct listnode *prev;
	34
	35	/* private member, use getdata() to retrieve, do not access directly */
	36	void *data;
718e3744	37	};
718e3744	38
d62a17ae	39	struct list {
	40	struct listnode *head;
	41	struct listnode *tail;
1eb8ef25	42
d62a17ae	43	/* invariant: count is the number of listnodes in the list */
d62a17ae	44	unsigned int count;
1eb8ef25	45
d62a17ae	46	/*
	47	* Returns -1 if val1 < val2, 0 if equal?, 1 if val1 > val2.
	48	* Used as definition of sorted for listnode_add_sort
	49	*/
	50	int (cmp)(void val1, void *val2);
1eb8ef25	51
d62a17ae	52	/* callback to free user-owned data when listnode is deleted. supplying
	53	* this callback is very much encouraged!
	54	*/
	55	void (del)(void val);
718e3744	56	};
718e3744	57
54dd6122	58	#define listnextnode(X) ((X) ? ((X)->next) : NULL)
39050c7e	59	#define listnextnode_unchecked(X) ((X)->next)
54dd6122	60	#define listhead(X) ((X) ? ((X)->head) : NULL)
64268e1a	61	#define listhead_unchecked(X) ((X)->head)
54dd6122	62	#define listtail(X) ((X) ? ((X)->tail) : NULL)
718e3744	63	#define listcount(X) ((X)->count)
718e3744	64	#define list_isempty(X) ((X)->head == NULL && (X)->tail == NULL)
67533c11 VJ	65	/* return X->data only if X and X->data are not NULL */
67533c11 VJ	66	#define listgetdata(X) (assert(X), assert((X)->data != NULL), (X)->data)
718e3744	67
6fd8c487 QY	68	/*
	69	* Create a new linked list.
	70	*
	71	* Returns:
	72	* the created linked list
	73	*/
	74	extern struct list *list_new(void);
	75
	76	/*
	77	* Add a new element to the tail of a list.
	78	*
	79	* Runtime is O(1).
	80	*
	81	* list
	82	* list to operate on
	83	*
	84	* data
	85	* element to add
	86	*/
	87	extern void listnode_add(struct list list, void data);
	88
9ea82f28 RW	89	/*
	90	* Add a new element to the beginning of a list.
	91	*
	92	* Runtime is O(1).
	93	*
	94	* list
	95	* list to operate on
	96	*
	97	* data
	98	* element to add
	99	*/
	100	extern void listnode_add_head(struct list list, void data);
	101
6fd8c487 QY	102	/*
	103	* Insert a new element into a list with insertion sort.
	104	*
	105	* If list->cmp is set, this function is used to determine the position to
	106	* insert the new element. If it is not set, this function is equivalent to
	107	* listnode_add.
	108	*
	109	* Runtime is O(N).
	110	*
	111	* list
	112	* list to operate on
	113	*
	114	* val
	115	* element to add
	116	*/
	117	extern void listnode_add_sort(struct list list, void val);
	118
	119	/*
	120	* Insert a new element into a list after another element.
	121	*
	122	* Runtime is O(1).
	123	*
	124	* list
	125	* list to operate on
	126	*
	127	* pp
	128	* listnode to insert after
	129	*
	130	* data
	131	* data to insert
	132	*
	133	* Returns:
	134	* pointer to newly created listnode that contains the inserted data
	135	*/
	136	extern struct listnode listnode_add_after(struct list list,
	137	struct listnode pp, void data);
	138
	139	/*
	140	* Insert a new element into a list before another element.
	141	*
	142	* Runtime is O(1).
	143	*
	144	* list
	145	* list to operate on
	146	*
	147	* pp
	148	* listnode to insert before
	149	*
	150	* data
	151	* data to insert
	152	*
	153	* Returns:
	154	* pointer to newly created listnode that contains the inserted data
	155	*/
	156	extern struct listnode listnode_add_before(struct list list,
	157	struct listnode pp, void data);
	158
	159	/*
	160	* Move a node to the tail of a list.
	161	*
	162	* Runtime is O(1).
	163	*
	164	* list
	165	* list to operate on
166	*
167	* node
168	* node to move to tail
169	*/
170	extern void listnode_move_to_tail(struct list list, struct listnode node);
171
172	/*
173	* Delete an element from a list.
174	*
175	* Runtime is O(N).
176	*
177	* list
178	* list to operate on
179	*
180	* data
181	* data to insert into list
182	*/
183	extern void listnode_delete(struct list list, void data);
184
185	/*
186	* Find the listnode corresponding to an element in a list.
187	*
188	* list
189	* list to operate on
190	*
191	* data
192	* data to search for
193	*
194	* Returns:
195	* pointer to listnode storing the given data if found, NULL otherwise
196	*/
197	extern struct listnode listnode_lookup(struct list list, void *data);
198
199	/*
200	* Retrieve the element at the head of a list.
201	*
202	* list
203	* list to operate on
204	*
205	* Returns:
206	* data at head of list, or NULL if list is empty
207	*/
208	extern void listnode_head(struct list list);
209
210	/*
211	* Duplicate a list.
212	*
213	* list
214	* list to duplicate
215	*
216	* Returns:
217	* copy of the list
218	*/
3a5c3bcb	219	extern struct list list_dup(struct list l);
6fd8c487 QY	220
	221	/*
	222	* Sort a list in place.
	223	*
	224	* The sorting algorithm used is quicksort. Runtimes are equivalent to those of
	225	* quicksort plus N. The sort is not stable.
	226	*
	227	* For portability reasons, the comparison function takes a pointer to pointer
	228	* to void. This pointer should be dereferenced to get the actual data pointer.
	229	* It is always safe to do this.
	230	*
	231	* list
	232	* list to sort
	233	*
	234	* cmp
	235	* comparison function for quicksort. Should return less than, equal to or
	236	* greater than zero if the first argument is less than, equal to or greater
	237	* than the second argument.
	238	*/
3a5c3bcb	239	extern void list_sort(struct list *list,
6fd8c487	240	int (cmp)(const void , const void *));
d62a17ae	241
6fd8c487 QY	242	/*
	243	* Delete a list and NULL its pointer.
	244	*
	245	* If non-null, list->del is called with each data element.
	246	*
	247	* plist
	248	* pointer to list pointer; this will be set to NULL after the list has been
	249	* deleted
	250	*/
6a154c88	251	extern void list_delete(struct list **plist);
6fd8c487	252
6fd8c487 QY	253	/*
	254	* Delete all nodes from a list without deleting the list itself.
	255	*
	256	* If non-null, list->del is called with each data element.
	257	*
	258	* list
	259	* list to operate on
	260	*/
	261	extern void list_delete_all_node(struct list *list);
718e3744	262
6fd8c487 QY	263	/*
	264	* Delete a node from a list.
	265	*
	266	* list->del is not called with the data associated with the node.
	267	*
	268	* Runtime is O(1).
	269	*
	270	* list
	271	* list to operate on
	272	*
	273	* node
	274	* the node to delete
	275	*/
	276	extern void list_delete_node(struct list list, struct listnode node);
718e3744	277
6fd8c487 QY	278	/*
	279	* Append a list to an existing list.
	280	*
	281	* Runtime is O(N) where N = listcount(add).
	282	*
	283	* list
	284	* list to append to
	285	*
	286	* add
	287	* list to append
	288	*/
	289	extern void list_add_list(struct list list, struct list add);
718e3744	290
d62a17ae	291	/* List iteration macro.
1eb8ef25	292	* Usage: for (ALL_LIST_ELEMENTS (...) { ... }
	293	* It is safe to delete the listnode using this macro.
	294	*/
d62a17ae	295	#define ALL_LIST_ELEMENTS(list, node, nextnode, data) \
	296	(node) = listhead(list), ((data) = NULL); \
	297	(node) != NULL \
343cd13e RW	298	&& ((data) = static_cast(data, listgetdata(node)), \
343cd13e RW	299	(nextnode) = node->next, 1); \
d62a17ae	300	(node) = (nextnode), ((data) = NULL)
1eb8ef25	301
	302	/* read-only list iteration macro.
	303	* Usage: as per ALL_LIST_ELEMENTS, but not safe to delete the listnode Only
	304	* use this macro when it is immediately obvious the listnode is not
	305	* deleted in the body of the loop. Does not have forward-reference overhead
	306	* of previous macro.
	307	*/
d62a17ae	308	#define ALL_LIST_ELEMENTS_RO(list, node, data) \
d62a17ae	309	(node) = listhead(list), ((data) = NULL); \
343cd13e	310	(node) != NULL && ((data) = static_cast(data, listgetdata(node)), 1); \
d62a17ae	311	(node) = listnextnode(node), ((data) = NULL)
718e3744	312
1eb8ef25	313	/* these do not cleanup list nodes and referenced data, as the functions
	314	* do - these macros simply {de,at}tach a listnode from/to a list.
	315	*/
d62a17ae	316
1eb8ef25	317	/* List node attach macro. */
d62a17ae	318	#define LISTNODE_ATTACH(L, N) \
	319	do { \
	320	(N)->prev = (L)->tail; \
	321	(N)->next = NULL; \
	322	if ((L)->head == NULL) \
	323	(L)->head = (N); \
	324	else \
	325	(L)->tail->next = (N); \
	326	(L)->tail = (N); \
	327	(L)->count++; \
	328	} while (0)
718e3744	329
1eb8ef25	330	/* List node detach macro. */
d62a17ae	331	#define LISTNODE_DETACH(L, N) \
	332	do { \
	333	if ((N)->prev) \
	334	(N)->prev->next = (N)->next; \
	335	else \
	336	(L)->head = (N)->next; \
	337	if ((N)->next) \
	338	(N)->next->prev = (N)->prev; \
	339	else \
	340	(L)->tail = (N)->prev; \
	341	(L)->count--; \
	342	} while (0)
718e3744	343
2fe55afe PG	344	extern struct listnode listnode_lookup_nocheck(struct list list, void *data);
2fe55afe PG	345
5e244469 RW	346	#ifdef __cplusplus
	347	}
	348	#endif
	349
718e3744	350	#endif /* _ZEBRA_LINKLIST_H */