[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 struct listnode *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, const 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, const 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);

/*
 * 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 **));

/*
 * Convert a list to an array of void pointers.
 *
 * Starts from the list head and ends either on the last node of the list or
 * when the provided array cannot store any more elements.
 *
 * list
 *    list to convert
 *
 * arr
 *    Pre-allocated array of void *
 *
 * arrlen
 *    Number of elements in arr
 *
 * Returns:
 *    arr
 */
void **list_to_array(struct list *list, void **arr, size_t arrlen);

/*
 * 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);

/*
 * Delete all nodes which satisfy a condition from a list.
 * Deletes the node if cond function returns true for the node.
 * If function ptr passed is NULL, it deletes all nodes
 *
 * list
 *    list to operate on
 * cond
 *    function pointer which takes node data as input and return true or false
 */

extern void list_filter_out_nodes(struct list *list, bool (*cond)(void *data));

/*
 * Insert a new element into a list with insertion sort if there is no
 * duplicate element present in the list. This assumes the input list is
 * sorted. If unsorted, it will check for duplicate until it finds out
 * the position to do insertion sort with the unsorted list.
 *
 * 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. duplicate element is determined by cmp function returning 0.
 *
 * Runtime is O(N).
 *
 * list
 *    list to operate on
 *
 * val
 *    element to add
 */

extern bool listnode_add_sort_nodup(struct list *list, void *val);
/* 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);

/*
 * Add a node to *list, if non-NULL. Otherwise, allocate a new list, mail
 * it back in *list, and add a new node.
 *
 * Return: the new node.
 */
extern struct listnode *listnode_add_force(struct list **list, void *val);

#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	*/
315999e9	87	extern struct listnode listnode_add(struct list list, void *data);
6fd8c487	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	*/
396cd636	183	extern void listnode_delete(struct list list, const void data);
6fd8c487 QY	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	*/
396cd636	197	extern struct listnode listnode_lookup(struct list list, const void *data);
6fd8c487 QY	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
6fd8c487 QY	210	/*
	211	* Sort a list in place.
	212	*
	213	* The sorting algorithm used is quicksort. Runtimes are equivalent to those of
	214	* quicksort plus N. The sort is not stable.
	215	*
	216	* For portability reasons, the comparison function takes a pointer to pointer
	217	* to void. This pointer should be dereferenced to get the actual data pointer.
	218	* It is always safe to do this.
	219	*
	220	* list
	221	* list to sort
	222	*
	223	* cmp
	224	* comparison function for quicksort. Should return less than, equal to or
	225	* greater than zero if the first argument is less than, equal to or greater
	226	* than the second argument.
	227	*/
3a5c3bcb	228	extern void list_sort(struct list *list,
6fd8c487	229	int (cmp)(const void , const void *));
4440e3cd QY	230
	231	/*
	232	* Convert a list to an array of void pointers.
	233	*
	234	* Starts from the list head and ends either on the last node of the list or
	235	* when the provided array cannot store any more elements.
	236	*
	237	* list
	238	* list to convert
	239	*
	240	* arr
	241	* Pre-allocated array of void *
	242	*
	243	* arrlen
	244	* Number of elements in arr
	245	*
	246	* Returns:
	247	* arr
	248	*/
	249	void *list_to_array(struct list list, void **arr, size_t arrlen);
d62a17ae	250
6fd8c487 QY	251	/*
	252	* Delete a list and NULL its pointer.
	253	*
	254	* If non-null, list->del is called with each data element.
	255	*
	256	* plist
	257	* pointer to list pointer; this will be set to NULL after the list has been
	258	* deleted
	259	*/
6a154c88	260	extern void list_delete(struct list **plist);
6fd8c487	261
6fd8c487 QY	262	/*
	263	* Delete all nodes from a list without deleting the list itself.
	264	*
	265	* If non-null, list->del is called with each data element.
	266	*
	267	* list
	268	* list to operate on
	269	*/
	270	extern void list_delete_all_node(struct list *list);
718e3744	271
6fd8c487 QY	272	/*
	273	* Delete a node from a list.
	274	*
	275	* list->del is not called with the data associated with the node.
	276	*
	277	* Runtime is O(1).
	278	*
	279	* list
	280	* list to operate on
	281	*
	282	* node
	283	* the node to delete
	284	*/
	285	extern void list_delete_node(struct list list, struct listnode node);
718e3744	286
9b68e496	287	/*
	288	* Delete all nodes which satisfy a condition from a list.
	289	* Deletes the node if cond function returns true for the node.
	290	* If function ptr passed is NULL, it deletes all nodes
	291	*
	292	* list
	293	* list to operate on
	294	* cond
2951a7a4	295	* function pointer which takes node data as input and return true or false
9b68e496	296	*/
	297
	298	extern void list_filter_out_nodes(struct list list, bool (cond)(void *data));
	299
	300	/*
	301	* Insert a new element into a list with insertion sort if there is no
	302	* duplicate element present in the list. This assumes the input list is
	303	* sorted. If unsorted, it will check for duplicate until it finds out
	304	* the position to do insertion sort with the unsorted list.
	305	*
	306	* If list->cmp is set, this function is used to determine the position to
	307	* insert the new element. If it is not set, this function is equivalent to
	308	* listnode_add. duplicate element is determined by cmp function returning 0.
	309	*
	310	* Runtime is O(N).
	311	*
	312	* list
	313	* list to operate on
	314	*
	315	* val
	316	* element to add
	317	*/
	318
	319	extern bool listnode_add_sort_nodup(struct list list, void val);
d62a17ae	320	/* List iteration macro.
1eb8ef25	321	* Usage: for (ALL_LIST_ELEMENTS (...) { ... }
	322	* It is safe to delete the listnode using this macro.
	323	*/
d62a17ae	324	#define ALL_LIST_ELEMENTS(list, node, nextnode, data) \
	325	(node) = listhead(list), ((data) = NULL); \
	326	(node) != NULL \
343cd13e RW	327	&& ((data) = static_cast(data, listgetdata(node)), \
343cd13e RW	328	(nextnode) = node->next, 1); \
d62a17ae	329	(node) = (nextnode), ((data) = NULL)
1eb8ef25	330
	331	/* read-only list iteration macro.
	332	* Usage: as per ALL_LIST_ELEMENTS, but not safe to delete the listnode Only
	333	* use this macro when it is immediately obvious the listnode is not
	334	* deleted in the body of the loop. Does not have forward-reference overhead
	335	* of previous macro.
	336	*/
d62a17ae	337	#define ALL_LIST_ELEMENTS_RO(list, node, data) \
d62a17ae	338	(node) = listhead(list), ((data) = NULL); \
343cd13e	339	(node) != NULL && ((data) = static_cast(data, listgetdata(node)), 1); \
d62a17ae	340	(node) = listnextnode(node), ((data) = NULL)
718e3744	341
1eb8ef25	342	/* these do not cleanup list nodes and referenced data, as the functions
	343	* do - these macros simply {de,at}tach a listnode from/to a list.
	344	*/
d62a17ae	345
1eb8ef25	346	/* List node attach macro. */
d62a17ae	347	#define LISTNODE_ATTACH(L, N) \
	348	do { \
	349	(N)->prev = (L)->tail; \
	350	(N)->next = NULL; \
	351	if ((L)->head == NULL) \
	352	(L)->head = (N); \
	353	else \
	354	(L)->tail->next = (N); \
	355	(L)->tail = (N); \
	356	(L)->count++; \
	357	} while (0)
718e3744	358
1eb8ef25	359	/* List node detach macro. */
d62a17ae	360	#define LISTNODE_DETACH(L, N) \
	361	do { \
	362	if ((N)->prev) \
	363	(N)->prev->next = (N)->next; \
	364	else \
	365	(L)->head = (N)->next; \
	366	if ((N)->next) \
	367	(N)->next->prev = (N)->prev; \
	368	else \
	369	(L)->tail = (N)->prev; \
	370	(L)->count--; \
	371	} while (0)
718e3744	372
2fe55afe PG	373	extern struct listnode listnode_lookup_nocheck(struct list list, void *data);
2fe55afe PG	374
75839aab MS	375	/*
	376	* Add a node to *list, if non-NULL. Otherwise, allocate a new list, mail
	377	* it back in *list, and add a new node.
	378	*
	379	* Return: the new node.
	380	*/
	381	extern struct listnode listnode_add_force(struct list list, void val);
33bca8a1	382
5e244469 RW	383	#ifdef __cplusplus
	384	}
	385	#endif
	386
718e3744	387	#endif /* _ZEBRA_LINKLIST_H */