[babeltrace.git] / src / common / list.h

/*
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (C) 2002 Free Software Foundation, Inc.
 * This file is part of the GNU C Library.
 * Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
 */

#ifndef _BT_LIST_H
#define _BT_LIST_H	1

/* The definitions of this file are adopted from those which can be
   found in the Linux kernel headers to enable people familiar with
   the latter find their way in these sources as well.  */

#ifdef __cplusplus
extern "C" {
#endif

/* Basic type for the double-link list.  */
struct bt_list_head
{
  struct bt_list_head *next;
  struct bt_list_head *prev;
};


/* Define a variable with the head and tail of the list.  */
#define BT_LIST_HEAD(name) \
  struct bt_list_head name = { &(name), &(name) }

/* Initialize a new list head.  */
#define BT_INIT_LIST_HEAD(ptr) \
  (ptr)->next = (ptr)->prev = (ptr)

#define BT_LIST_HEAD_INIT(name) { .prev = &(name), .next = &(name) }

/* Add new element at the head of the list.  */
static inline void
bt_list_add (struct bt_list_head *newp, struct bt_list_head *head)
{
  head->next->prev = newp;
  newp->next = head->next;
  newp->prev = head;
  head->next = newp;
}


/* Add new element at the tail of the list.  */
static inline void
bt_list_add_tail (struct bt_list_head *newp, struct bt_list_head *head)
{
  head->prev->next = newp;
  newp->next = head;
  newp->prev = head->prev;
  head->prev = newp;
}


/* Remove element from list.  */
static inline void
__bt_list_del (struct bt_list_head *prev, struct bt_list_head *next)
{
  next->prev = prev;
  prev->next = next;
}

/* Remove element from list.  */
static inline void
bt_list_del (struct bt_list_head *elem)
{
  __bt_list_del (elem->prev, elem->next);
}

/* delete from list, add to another list as head */
static inline void
bt_list_move (struct bt_list_head *elem, struct bt_list_head *head)
{
  __bt_list_del (elem->prev, elem->next);
  bt_list_add (elem, head);
}

/* replace an old entry.
 */
static inline void
bt_list_replace(struct bt_list_head *old, struct bt_list_head *_new)
{
	_new->next = old->next;
	_new->prev = old->prev;
	_new->prev->next = _new;
	_new->next->prev = _new;
}

/* Join two lists.  */
static inline void
bt_list_splice (struct bt_list_head *add, struct bt_list_head *head)
{
  /* Do nothing if the list which gets added is empty.  */
  if (add != add->next)
    {
      add->next->prev = head;
      add->prev->next = head->next;
      head->next->prev = add->prev;
      head->next = add->next;
    }
}


/* Get typed element from list at a given position.  */
#define bt_list_entry(ptr, type, member) \
  ((type *) ((char *) (ptr) - (uintptr_t) (&((type *) 0)->member)))


/* Iterate forward over the elements of the list.  */
#define bt_list_for_each(pos, head) \
  for (pos = (head)->next; pos != (head); pos = pos->next)


/* Iterate forward over the elements of the list.  */
#define bt_list_for_each_prev(pos, head) \
  for (pos = (head)->prev; pos != (head); pos = pos->prev)


/* Iterate backwards over the elements list.  The list elements can be
   removed from the list while doing this.  */
#define bt_list_for_each_prev_safe(pos, p, head) \
  for (pos = (head)->prev, p = pos->prev; \
       pos != (head); \
       pos = p, p = pos->prev)

#define bt_list_for_each_entry(pos, head, member)				\
	for (pos = bt_list_entry((head)->next, typeof(*pos), member);	\
	     &pos->member != (head);					\
	     pos = bt_list_entry(pos->member.next, typeof(*pos), member))

#define bt_list_for_each_entry_reverse(pos, head, member)			\
	for (pos = bt_list_entry((head)->prev, typeof(*pos), member);	\
	     &pos->member != (head);					\
	     pos = bt_list_entry(pos->member.prev, typeof(*pos), member))

#define bt_list_for_each_entry_safe(pos, p, head, member)			\
	for (pos = bt_list_entry((head)->next, typeof(*pos), member),	\
		     p = bt_list_entry(pos->member.next,typeof(*pos), member); \
	     &pos->member != (head);					\
	     pos = p, p = bt_list_entry(pos->member.next, typeof(*pos), member))

static inline int bt_list_empty(struct bt_list_head *head)
{
	return head == head->next;
}

static inline void bt_list_replace_init(struct bt_list_head *old,
				     struct bt_list_head *_new)
{
	struct bt_list_head *head = old->next;
	bt_list_del(old);
	bt_list_add_tail(_new, head);
	BT_INIT_LIST_HEAD(old);
}

#ifdef __cplusplus
}
#endif

#endif	/* _BT_LIST_H */
Commit	Line	Data
	1	/*
	2	* SPDX-License-Identifier: LGPL-2.1-only
	3	*
	4	* Copyright (C) 2002 Free Software Foundation, Inc.
	5	* This file is part of the GNU C Library.
	6	* Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
	7	*/
	8
	9	#ifndef _BT_LIST_H
	10	#define _BT_LIST_H 1
	11
	12	/* The definitions of this file are adopted from those which can be
	13	found in the Linux kernel headers to enable people familiar with
	14	the latter find their way in these sources as well. */
	15
	16	#ifdef __cplusplus
	17	extern "C" {
	18	#endif
	19
	20	/* Basic type for the double-link list. */
	21	struct bt_list_head
	22	{
	23	struct bt_list_head *next;
	24	struct bt_list_head *prev;
	25	};
	26
	27
	28	/* Define a variable with the head and tail of the list. */
	29	#define BT_LIST_HEAD(name) \
	30	struct bt_list_head name = { &(name), &(name) }
	31
	32	/* Initialize a new list head. */
	33	#define BT_INIT_LIST_HEAD(ptr) \
	34	(ptr)->next = (ptr)->prev = (ptr)
	35
	36	#define BT_LIST_HEAD_INIT(name) { .prev = &(name), .next = &(name) }
	37
	38	/* Add new element at the head of the list. */
	39	static inline void
	40	bt_list_add (struct bt_list_head newp, struct bt_list_head head)
	41	{
	42	head->next->prev = newp;
	43	newp->next = head->next;
	44	newp->prev = head;
	45	head->next = newp;
	46	}
	47
	48
	49	/* Add new element at the tail of the list. */
	50	static inline void
	51	bt_list_add_tail (struct bt_list_head newp, struct bt_list_head head)
	52	{
	53	head->prev->next = newp;
	54	newp->next = head;
	55	newp->prev = head->prev;
	56	head->prev = newp;
	57	}
	58
	59
	60	/* Remove element from list. */
	61	static inline void
	62	__bt_list_del (struct bt_list_head prev, struct bt_list_head next)
	63	{
	64	next->prev = prev;
	65	prev->next = next;
	66	}
	67
	68	/* Remove element from list. */
	69	static inline void
	70	bt_list_del (struct bt_list_head *elem)
	71	{
	72	__bt_list_del (elem->prev, elem->next);
	73	}
	74
	75	/* delete from list, add to another list as head */
	76	static inline void
	77	bt_list_move (struct bt_list_head elem, struct bt_list_head head)
	78	{
	79	__bt_list_del (elem->prev, elem->next);
	80	bt_list_add (elem, head);
	81	}
	82
	83	/* replace an old entry.
	84	*/
	85	static inline void
	86	bt_list_replace(struct bt_list_head old, struct bt_list_head _new)
	87	{
	88	_new->next = old->next;
	89	_new->prev = old->prev;
	90	_new->prev->next = _new;
	91	_new->next->prev = _new;
	92	}
	93
	94	/* Join two lists. */
	95	static inline void
	96	bt_list_splice (struct bt_list_head add, struct bt_list_head head)
	97	{
	98	/* Do nothing if the list which gets added is empty. */
	99	if (add != add->next)
	100	{
	101	add->next->prev = head;
	102	add->prev->next = head->next;
	103	head->next->prev = add->prev;
	104	head->next = add->next;
	105	}
	106	}
	107
	108
	109	/* Get typed element from list at a given position. */
	110	#define bt_list_entry(ptr, type, member) \
	111	((type ) ((char ) (ptr) - (uintptr_t) (&((type *) 0)->member)))
	112
	113
	114
	115	/* Iterate forward over the elements of the list. */
	116	#define bt_list_for_each(pos, head) \
	117	for (pos = (head)->next; pos != (head); pos = pos->next)
	118
	119
	120	/* Iterate forward over the elements of the list. */
	121	#define bt_list_for_each_prev(pos, head) \
	122	for (pos = (head)->prev; pos != (head); pos = pos->prev)
	123
	124
	125	/* Iterate backwards over the elements list. The list elements can be
	126	removed from the list while doing this. */
	127	#define bt_list_for_each_prev_safe(pos, p, head) \
	128	for (pos = (head)->prev, p = pos->prev; \
	129	pos != (head); \
	130	pos = p, p = pos->prev)
	131
	132	#define bt_list_for_each_entry(pos, head, member) \
	133	for (pos = bt_list_entry((head)->next, typeof(*pos), member); \
	134	&pos->member != (head); \
	135	pos = bt_list_entry(pos->member.next, typeof(*pos), member))
	136
	137	#define bt_list_for_each_entry_reverse(pos, head, member) \
	138	for (pos = bt_list_entry((head)->prev, typeof(*pos), member); \
	139	&pos->member != (head); \
	140	pos = bt_list_entry(pos->member.prev, typeof(*pos), member))
	141
	142	#define bt_list_for_each_entry_safe(pos, p, head, member) \
	143	for (pos = bt_list_entry((head)->next, typeof(*pos), member), \
	144	p = bt_list_entry(pos->member.next,typeof(*pos), member); \
	145	&pos->member != (head); \
	146	pos = p, p = bt_list_entry(pos->member.next, typeof(*pos), member))
	147
	148	static inline int bt_list_empty(struct bt_list_head *head)
	149	{
	150	return head == head->next;
	151	}
	152
	153	static inline void bt_list_replace_init(struct bt_list_head *old,
	154	struct bt_list_head *_new)
	155	{
	156	struct bt_list_head *head = old->next;
	157	bt_list_del(old);
	158	bt_list_add_tail(_new, head);
	159	BT_INIT_LIST_HEAD(old);
	160	}
	161
	162	#ifdef __cplusplus
	163	}
	164	#endif
	165
	166	#endif /* _BT_LIST_H */