linkedlists.h File Reference

current

struct {                      \
   struct type *next;                  \
}

  struct list_entry {
   ...
   AST_LIST_ENTRY(list_entry) list;
  }

struct name {                       \
   struct type *first;                 \
   struct type *last;                  \
   ast_mutex_t lock;                \
}

  static AST_LIST_HEAD(entry_list, entry) entries;

{              \
   (head)->first = NULL;                  \
   (head)->last = NULL;                \
   ast_mutex_destroy(&(head)->lock);            \
}

{              \
   (head)->first = NULL;                  \
   (head)->last = NULL;                \
   ast_mutex_init(&(head)->lock);               \
}

{           \
   (head)->first = NULL;                  \
   (head)->last = NULL;                \
}

{     \
   .first = NULL,             \
   .last = NULL,              \
   .lock = AST_MUTEX_INIT_VALUE,       \
   }

struct name {                       \
   struct type *first;                 \
   struct type *last;                  \
}

  static AST_LIST_HEAD_NOLOCK(entry_list, entry) entries;

{  \
   .first = NULL,             \
   .last = NULL,              \
   }

struct name {                       \
   struct type *first;                 \
   struct type *last;                  \
} name = AST_LIST_HEAD_NOLOCK_INIT_VALUE

do {           \
   (head)->first = (entry);               \
   (head)->last = (entry);                \
   ast_mutex_init(&(head)->lock);               \
} while (0)

do {        \
   (head)->first = (entry);               \
   (head)->last = (entry);                \
} while (0)

struct name {                       \
   struct type *first;                 \
   struct type *last;                  \
   ast_mutex_t lock;                \
} name = AST_LIST_HEAD_INIT_VALUE

  static AST_LIST_HEAD_STATIC(entry_list, entry);

  static AST_LIST_HEAD(entry_list, list_entry) entries;
  ...
  struct list_entry {
   ...
   AST_LIST_ENTRY(list_entry) list;
  }
  ...
  struct list_entry *current;
  ...
  AST_LIST_TRAVERSE(&entries, current, list) {
     (do something with current here)
  }


Defines
#define	AST_LIST_APPEND_LIST(head, list, field)
	Appends a whole list to the tail of a list.
#define	AST_LIST_EMPTY(head) (AST_LIST_FIRST(head) == NULL)
	Checks whether the specified list contains any entries.
#define	AST_LIST_ENTRY(type)
	Declare a forward link structure inside a list entry.
#define	AST_LIST_FIRST(head) ((head)->first)
	Returns the first entry contained in a list.
#define	AST_LIST_HEAD(name, type)
	Defines a structure to be used to hold a list of specified type.
#define	AST_LIST_HEAD_DESTROY(head)
	Destroys a list head structure.
#define	AST_LIST_HEAD_INIT(head)
	Initializes a list head structure.
#define	AST_LIST_HEAD_INIT_NOLOCK(head)
	Initializes a list head structure.
#define	AST_LIST_HEAD_INIT_VALUE
	Defines initial values for a declaration of AST_LIST_HEAD.
#define	AST_LIST_HEAD_NOLOCK(name, type)
	Defines a structure to be used to hold a list of specified type (with no lock).
#define	AST_LIST_HEAD_NOLOCK_INIT_VALUE
	Defines initial values for a declaration of AST_LIST_HEAD_NOLOCK.
#define	AST_LIST_HEAD_NOLOCK_STATIC(name, type)
	Defines a structure to be used to hold a list of specified type, statically initialized.
#define	AST_LIST_HEAD_SET(head, entry)
	Initializes a list head structure with a specified first entry.
#define	AST_LIST_HEAD_SET_NOLOCK(head, entry)
	Initializes a list head structure with a specified first entry.
#define	AST_LIST_HEAD_STATIC(name, type)
	Defines a structure to be used to hold a list of specified type, statically initialized.
#define	AST_LIST_INSERT_AFTER(head, listelm, elm, field)
	Inserts a list entry after a given entry.
#define	AST_LIST_INSERT_BEFORE_CURRENT(head, elm, field)
	Inserts a list entry before the current entry during a traversal.
#define	AST_LIST_INSERT_HEAD(head, elm, field)
	Inserts a list entry at the head of a list.
#define	AST_LIST_INSERT_TAIL(head, elm, field)
	Appends a list entry to the tail of a list.
#define	AST_LIST_LAST(head) ((head)->last)
	Returns the last entry contained in a list.
#define	AST_LIST_LOCK(head) ast_mutex_lock(&(head)->lock)
	Locks a list.
#define	AST_LIST_NEXT(elm, field) ((elm)->field.next)
	Returns the next entry in the list after the given entry.
#define	AST_LIST_REMOVE(head, elm, field)
	Removes a specific entry from a list.
#define	AST_LIST_REMOVE_CURRENT(head, field)
	Removes the current entry from a list during a traversal.
#define	AST_LIST_REMOVE_HEAD(head, field)
	Removes and returns the head entry from a list.
#define	AST_LIST_TRAVERSE(head, var, field) for((var) = (head)->first; (var); (var) = (var)->field.next)
	Loops over (traverses) the entries in a list.
#define	AST_LIST_TRAVERSE_SAFE_BEGIN(head, var, field)
	Loops safely over (traverses) the entries in a list.
#define	AST_LIST_TRAVERSE_SAFE_END }
	Closes a safe loop traversal block.
#define	AST_LIST_TRYLOCK(head) ast_mutex_trylock(&(head)->lock)
	Locks a list, without blocking if the list is locked.
#define	AST_LIST_UNLOCK(head) ast_mutex_unlock(&(head)->lock)
	Attempts to unlock a list.
#define	AST_RWLIST_APPEND_LIST AST_LIST_APPEND_LIST
#define	AST_RWLIST_EMPTY AST_LIST_EMPTY
#define	AST_RWLIST_ENTRY AST_LIST_ENTRY
#define	AST_RWLIST_FIRST AST_LIST_FIRST
#define	AST_RWLIST_HEAD(name, type)
	Defines a structure to be used to hold a read/write list of specified type.
#define	AST_RWLIST_HEAD_DESTROY(head)
	Destroys an rwlist head structure.
#define	AST_RWLIST_HEAD_INIT(head)
	Initializes an rwlist head structure.
#define	AST_RWLIST_HEAD_INIT_VALUE
	Defines initial values for a declaration of AST_RWLIST_HEAD.
#define	AST_RWLIST_HEAD_SET(head, entry)
	Initializes an rwlist head structure with a specified first entry.
#define	AST_RWLIST_HEAD_STATIC(name, type)
	Defines a structure to be used to hold a read/write list of specified type, statically initialized.
#define	AST_RWLIST_INSERT_AFTER AST_LIST_INSERT_AFTER
#define	AST_RWLIST_INSERT_BEFORE_CURRENT AST_LIST_INSERT_BEFORE_CURRENT
#define	AST_RWLIST_INSERT_HEAD AST_LIST_INSERT_HEAD
#define	AST_RWLIST_INSERT_TAIL AST_LIST_INSERT_TAIL
#define	AST_RWLIST_LAST AST_LIST_LAST
#define	AST_RWLIST_NEXT AST_LIST_NEXT
#define	AST_RWLIST_RDLOCK(head) ast_rwlock_rdlock(&(head)->lock)
	Read locks a list.
#define	AST_RWLIST_REMOVE AST_LIST_REMOVE
#define	AST_RWLIST_REMOVE_CURRENT AST_LIST_REMOVE_CURRENT
#define	AST_RWLIST_REMOVE_HEAD AST_LIST_REMOVE_HEAD
#define	AST_RWLIST_TRAVERSE AST_LIST_TRAVERSE
#define	AST_RWLIST_TRAVERSE_SAFE_BEGIN AST_LIST_TRAVERSE_SAFE_BEGIN
#define	AST_RWLIST_TRAVERSE_SAFE_END AST_LIST_TRAVERSE_SAFE_END
#define	AST_RWLIST_TRYRDLOCK(head) ast_rwlock_tryrdlock(&(head)->lock)
	Read locks a list, without blocking if the list is locked.
#define	AST_RWLIST_TRYWRLOCK(head) ast_rwlock_trywrlock(&(head)->lock)
	Write locks a list, without blocking if the list is locked.
#define	AST_RWLIST_UNLOCK(head) ast_rwlock_unlock(&(head)->lock)
	Attempts to unlock a read/write based list.
#define	AST_RWLIST_WRLOCK(head) ast_rwlock_wrlock(&(head)->lock)
	Write locks a list.

Asterisk developer's documentation :: Codename Pineapple

linkedlists.h File Reference

Detailed Description

Defines

Define Documentation