Asterisk - The Open Source Telephony Project  GIT-master-a24979a
Macros
linkedlists.h File Reference

A set of macros to manage forward-linked lists. More...

#include "asterisk/lock.h"
Include dependency graph for linkedlists.h:

Go to the source code of this file.

Macros

#define AST_LIST_APPEND_LIST(head, list, field)
 Appends a whole list to the tail of a list. More...
 
#define AST_LIST_EMPTY(head)   (AST_LIST_FIRST(head) == NULL)
 Checks whether the specified list contains any entries. More...
 
#define AST_LIST_ENTRY(type)
 Declare a forward link structure inside a list entry. More...
 
#define AST_LIST_FIRST(head)   ((head)->first)
 Returns the first entry contained in a list. More...
 
#define AST_LIST_HEAD(name, type)
 Defines a structure to be used to hold a list of specified type. More...
 
#define AST_LIST_HEAD_DESTROY(head)
 Destroys a list head structure. More...
 
#define AST_LIST_HEAD_INIT(head)
 Initializes a list head structure. More...
 
#define AST_LIST_HEAD_INIT_NOLOCK(head)
 Initializes a list head structure. More...
 
#define AST_LIST_HEAD_INIT_VALUE
 Defines initial values for a declaration of AST_LIST_HEAD. More...
 
#define AST_LIST_HEAD_NOLOCK(name, type)
 Defines a structure to be used to hold a list of specified type (with no lock). More...
 
#define AST_LIST_HEAD_NOLOCK_INIT_VALUE
 Defines initial values for a declaration of AST_LIST_HEAD_NOLOCK. More...
 
#define AST_LIST_HEAD_NOLOCK_STATIC(name, type)
 Defines a structure to be used to hold a list of specified type, statically initialized. More...
 
#define AST_LIST_HEAD_SET(head, entry)
 Initializes a list head structure with a specified first entry. More...
 
#define AST_LIST_HEAD_SET_NOLOCK(head, entry)
 Initializes a list head structure with a specified first entry. More...
 
#define AST_LIST_HEAD_STATIC(name, type)
 Defines a structure to be used to hold a list of specified type, statically initialized. More...
 
#define AST_LIST_INSERT_AFTER(head, listelm, elm, field)
 Inserts a list entry after a given entry. More...
 
#define AST_LIST_INSERT_BEFORE_CURRENT(elm, field)
 Inserts a list entry before the current entry during a traversal. More...
 
#define AST_LIST_INSERT_HEAD(head, elm, field)
 Inserts a list entry at the head of a list. More...
 
#define AST_LIST_INSERT_LIST_AFTER(head, list, elm, field)
 Inserts a whole list after a specific entry in a list. More...
 
#define AST_LIST_INSERT_SORTALPHA(head, elm, field, sortfield)
 Inserts a list entry into a alphabetically sorted list. More...
 
#define AST_LIST_INSERT_TAIL(head, elm, field)
 Appends a list entry to the tail of a list. More...
 
#define AST_LIST_LAST(head)   ((head)->last)
 Returns the last entry contained in a list. More...
 
#define AST_LIST_LOCK(head)    ast_mutex_lock(&(head)->lock)
 Locks a list. More...
 
#define AST_LIST_MOVE_CURRENT(newhead, field)
 Move the current list entry to another list. More...
 
#define AST_LIST_NEXT(elm, field)   ((elm)->field.next)
 Returns the next entry in the list after the given entry. More...
 
#define AST_LIST_REMOVE(head, elm, field)
 Removes a specific entry from a list. More...
 
#define AST_LIST_REMOVE_CURRENT(field)
 Removes the current entry from a list during a traversal. More...
 
#define AST_LIST_REMOVE_HEAD(head, field)
 Removes and returns the head entry from a list. More...
 
#define AST_LIST_TRAVERSE(head, var, field)    for((var) = (head)->first; (var); (var) = (var)->field.next)
 Loops over (traverses) the entries in a list. More...
 
#define AST_LIST_TRAVERSE_SAFE_BEGIN(head, var, field)
 Loops safely over (traverses) the entries in a list. More...
 
#define AST_LIST_TRAVERSE_SAFE_END   }
 Closes a safe loop traversal block. More...
 
#define AST_LIST_TRYLOCK(head)    ast_mutex_trylock(&(head)->lock)
 Locks a list, without blocking if the list is locked. More...
 
#define AST_LIST_UNLOCK(head)    ast_mutex_unlock(&(head)->lock)
 Attempts to unlock a list. More...
 
#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. More...
 
#define AST_RWLIST_HEAD_DESTROY(head)
 Destroys an rwlist head structure. More...
 
#define AST_RWLIST_HEAD_INIT(head)
 Initializes an rwlist head structure. More...
 
#define AST_RWLIST_HEAD_INIT_VALUE
 Defines initial values for a declaration of AST_RWLIST_HEAD. More...
 
#define AST_RWLIST_HEAD_SET(head, entry)
 Initializes an rwlist head structure with a specified first entry. More...
 
#define AST_RWLIST_HEAD_STATIC(name, type)
 Defines a structure to be used to hold a read/write list of specified type, statically initialized. More...
 
#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_LIST_AFTER   AST_LIST_INSERT_LIST_AFTER
 
#define AST_RWLIST_INSERT_SORTALPHA   AST_LIST_INSERT_SORTALPHA
 
#define AST_RWLIST_INSERT_TAIL   AST_LIST_INSERT_TAIL
 
#define AST_RWLIST_LAST   AST_LIST_LAST
 
#define AST_RWLIST_MOVE_CURRENT   AST_LIST_MOVE_CURRENT
 
#define AST_RWLIST_NEXT   AST_LIST_NEXT
 
#define AST_RWLIST_RDLOCK(head)    ast_rwlock_rdlock(&(head)->lock)
 Read locks a list. More...
 
#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_TIMEDRDLOCK(head, ts)    ast_rwlock_timedrdlock(&(head)->lock, ts)
 Read locks a list, with timeout. More...
 
#define AST_RWLIST_TIMEDWRLOCK(head, ts)   ast_rwlock_timedwrlock(&(head)->lock, ts)
 Write locks a list, with timeout. More...
 
#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. More...
 
#define AST_RWLIST_TRYWRLOCK(head)    ast_rwlock_trywrlock(&(head)->lock)
 Write locks a list, without blocking if the list is locked. More...
 
#define AST_RWLIST_UNLOCK(head)    ast_rwlock_unlock(&(head)->lock)
 Attempts to unlock a read/write based list. More...
 
#define AST_RWLIST_WRLOCK(head)    ast_rwlock_wrlock(&(head)->lock)
 Write locks a list. More...
 

Detailed Description

A set of macros to manage forward-linked lists.

Definition in file linkedlists.h.

Macro Definition Documentation

◆ AST_LIST_APPEND_LIST

#define AST_LIST_APPEND_LIST (   head,
  list,
  field 
)

Appends a whole list to the tail of a list.

Parameters
headThis is a pointer to the list head structure
listThis is a pointer to the list to be appended.
fieldThis is the name of the field (declared using AST_LIST_ENTRY()) used to link entries of this list together.

Note: The source list (the list parameter) will be empty after calling this macro (the list entries are moved to the target list).

Definition at line 783 of file linkedlists.h.

◆ AST_LIST_EMPTY

#define AST_LIST_EMPTY (   head)    (AST_LIST_FIRST(head) == NULL)

Checks whether the specified list contains any entries.

Parameters
headThis is a pointer to the list head structure
Returns
zero if the list has entries
non-zero if not.

Definition at line 450 of file linkedlists.h.

◆ AST_LIST_ENTRY

#define AST_LIST_ENTRY (   type)
Value:
struct { \
struct type *next; \
}
static const char type[]
Definition: chan_ooh323.c:109

Declare a forward link structure inside a list entry.

Parameters
typeThis is the type of each list entry.

This macro declares a structure to be used to link list entries together. It must be used inside the definition of the structure named in type, as follows:

struct list_entry {
...
AST_LIST_ENTRY(list_entry) list;
}
#define AST_LIST_ENTRY(type)
Declare a forward link structure inside a list entry.
Definition: linkedlists.h:410

The field name list here is arbitrary, and can be anything you wish.

Definition at line 410 of file linkedlists.h.

◆ AST_LIST_FIRST

#define AST_LIST_FIRST (   head)    ((head)->first)

Returns the first entry contained in a list.

Parameters
headThis is a pointer to the list head structure

Definition at line 421 of file linkedlists.h.

◆ AST_LIST_HEAD

#define AST_LIST_HEAD (   name,
  type 
)
Value:
struct name { \
struct type *first; \
struct type *last; \
ast_mutex_t lock; \
}
struct sla_ringing_trunk * first
Definition: app_meetme.c:1094
ast_mutex_t lock
Definition: app_meetme.c:1093
struct sla_ringing_trunk * last
Definition: app_meetme.c:1094
static const char name[]
Definition: format_mp3.c:68

Defines a structure to be used to hold a list of specified type.

Parameters
nameThis will be the name of the defined structure.
typeThis is the type of each list entry.

This macro creates a structure definition that can be used to hold a list of the entries of type type. It does not actually declare (allocate) a structure; to do that, either follow this macro with the desired name of the instance you wish to declare, or use the specified name to declare instances elsewhere.

Example usage:

static AST_LIST_HEAD(entry_list, entry) entries;
#define AST_LIST_HEAD(name, type)
Defines a structure to be used to hold a list of specified type.
Definition: linkedlists.h:173
Definition: search.h:40

This would define struct entry_list, and declare an instance of it named entries, all intended to hold a list of type struct entry.

Definition at line 173 of file linkedlists.h.

◆ AST_LIST_HEAD_DESTROY

#define AST_LIST_HEAD_DESTROY (   head)
Value:
{ \
(head)->first = NULL; \
(head)->last = NULL; \
ast_mutex_destroy(&(head)->lock); \
}
#define NULL
Definition: resample.c:96

Destroys a list head structure.

Parameters
headThis is a pointer to the list head structure

This macro destroys a list head structure by setting the head entry to NULL (empty list) and destroying the embedded lock. It does not free the structure from memory.

Definition at line 653 of file linkedlists.h.

◆ AST_LIST_HEAD_INIT

#define AST_LIST_HEAD_INIT (   head)
Value:
{ \
(head)->first = NULL; \
(head)->last = NULL; \
ast_mutex_init(&(head)->lock); \
}

Initializes a list head structure.

Parameters
headThis is a pointer to the list head structure

This macro initializes a list head structure by setting the head entry to NULL (empty list) and recreating the embedded lock.

Definition at line 626 of file linkedlists.h.

◆ AST_LIST_HEAD_INIT_NOLOCK

#define AST_LIST_HEAD_INIT_NOLOCK (   head)
Value:
{ \
(head)->first = NULL; \
(head)->last = NULL; \
}

Initializes a list head structure.

Parameters
headThis is a pointer to the list head structure

This macro initializes a list head structure by setting the head entry to NULL (empty list). There is no embedded lock handling with this macro.

Definition at line 681 of file linkedlists.h.

◆ AST_LIST_HEAD_INIT_VALUE

#define AST_LIST_HEAD_INIT_VALUE
Value:
{ \
.first = NULL, \
.last = NULL, \
}
#define AST_MUTEX_INIT_VALUE
Definition: lock.h:95

Defines initial values for a declaration of AST_LIST_HEAD.

Definition at line 234 of file linkedlists.h.

◆ AST_LIST_HEAD_NOLOCK

#define AST_LIST_HEAD_NOLOCK (   name,
  type 
)
Value:
struct name { \
struct type *first; \
struct type *last; \
}

Defines a structure to be used to hold a list of specified type (with no lock).

Parameters
nameThis will be the name of the defined structure.
typeThis is the type of each list entry.

This macro creates a structure definition that can be used to hold a list of the entries of type type. It does not actually declare (allocate) a structure; to do that, either follow this macro with the desired name of the instance you wish to declare, or use the specified name to declare instances elsewhere.

Example usage:

AST_LIST_HEAD_NOLOCK(contactliststruct, contact)

This would define struct entry_list, and declare an instance of it named entries, all intended to hold a list of type struct entry.

Definition at line 225 of file linkedlists.h.

◆ AST_LIST_HEAD_NOLOCK_INIT_VALUE

#define AST_LIST_HEAD_NOLOCK_INIT_VALUE
Value:
{ \
.first = NULL, \
.last = NULL, \
}

Defines initial values for a declaration of AST_LIST_HEAD_NOLOCK.

Definition at line 252 of file linkedlists.h.

◆ AST_LIST_HEAD_NOLOCK_STATIC

#define AST_LIST_HEAD_NOLOCK_STATIC (   name,
  type 
)
Value:
struct name { \
struct type *first; \
struct type *last; \
#define AST_LIST_HEAD_NOLOCK_INIT_VALUE
Defines initial values for a declaration of AST_LIST_HEAD_NOLOCK.
Definition: linkedlists.h:252

Defines a structure to be used to hold a list of specified type, statically initialized.

This is the same as AST_LIST_HEAD_STATIC, except without the lock included.

Definition at line 346 of file linkedlists.h.

◆ AST_LIST_HEAD_SET

#define AST_LIST_HEAD_SET (   head,
  entry 
)
Value:
do { \
(head)->first = (entry); \
(head)->last = (entry); \
ast_mutex_init(&(head)->lock); \
} while (0)

Initializes a list head structure with a specified first entry.

Parameters
headThis is a pointer to the list head structure
entrypointer to the list entry that will become the head of the list

This macro initializes a list head structure by setting the head entry to the supplied value and recreating the embedded lock.

Definition at line 360 of file linkedlists.h.

◆ AST_LIST_HEAD_SET_NOLOCK

#define AST_LIST_HEAD_SET_NOLOCK (   head,
  entry 
)
Value:
do { \
(head)->first = (entry); \
(head)->last = (entry); \
} while (0)

Initializes a list head structure with a specified first entry.

Parameters
headThis is a pointer to the list head structure
entrypointer to the list entry that will become the head of the list

This macro initializes a list head structure by setting the head entry to the supplied value.

Definition at line 388 of file linkedlists.h.

◆ AST_LIST_HEAD_STATIC

#define AST_LIST_HEAD_STATIC (   name,
  type 
)
Value:
struct name { \
struct type *first; \
struct type *last; \
ast_mutex_t lock; \
#define AST_LIST_HEAD_INIT_VALUE
Defines initial values for a declaration of AST_LIST_HEAD.
Definition: linkedlists.h:234

Defines a structure to be used to hold a list of specified type, statically initialized.

Parameters
nameThis will be the name of the defined structure.
typeThis is the type of each list entry.

This macro creates a structure definition that can be used to hold a list of the entries of type type, and allocates an instance of it, initialized to be empty.

Example usage:

#define AST_LIST_HEAD_STATIC(name, type)
Defines a structure to be used to hold a list of specified type, statically initialized.
Definition: linkedlists.h:291

This would define struct entry_list, intended to hold a list of type struct entry.

Definition at line 291 of file linkedlists.h.

◆ AST_LIST_INSERT_AFTER

#define AST_LIST_INSERT_AFTER (   head,
  listelm,
  elm,
  field 
)

Inserts a list entry after a given entry.

Parameters
headThis is a pointer to the list head structure
listelmThis is a pointer to the entry after which the new entry should be inserted.
elmThis is a pointer to the entry to be inserted.
fieldThis is the name of the field (declared using AST_LIST_ENTRY()) used to link entries of this list together.

Definition at line 695 of file linkedlists.h.

◆ AST_LIST_INSERT_BEFORE_CURRENT

#define AST_LIST_INSERT_BEFORE_CURRENT (   elm,
  field 
)

Inserts a list entry before the current entry during a traversal.

Parameters
elmThis is a pointer to the entry to be inserted.
fieldThis is the name of the field (declared using AST_LIST_ENTRY()) used to link entries of this list together.
Note
This macro can only be used inside an AST_LIST_TRAVERSE_SAFE_BEGIN() block.

Definition at line 599 of file linkedlists.h.

◆ AST_LIST_INSERT_HEAD

#define AST_LIST_INSERT_HEAD (   head,
  elm,
  field 
)

Inserts a list entry at the head of a list.

Parameters
headThis is a pointer to the list head structure
elmThis is a pointer to the entry to be inserted.
fieldThis is the name of the field (declared using AST_LIST_ENTRY()) used to link entries of this list together.

Definition at line 711 of file linkedlists.h.

◆ AST_LIST_INSERT_LIST_AFTER

#define AST_LIST_INSERT_LIST_AFTER (   head,
  list,
  elm,
  field 
)

Inserts a whole list after a specific entry in a list.

Parameters
headThis is a pointer to the list head structure
listThis is a pointer to the list to be inserted.
elmThis is a pointer to the entry after which the new list should be inserted.
fieldThis is the name of the field (declared using AST_LIST_ENTRY()) used to link entries of the lists together.

Note: The source list (the list parameter) will be empty after calling this macro (the list entries are moved to the target list).

Definition at line 812 of file linkedlists.h.

◆ AST_LIST_INSERT_SORTALPHA

#define AST_LIST_INSERT_SORTALPHA (   head,
  elm,
  field,
  sortfield 
)

Inserts a list entry into a alphabetically sorted list.

Parameters
headPointer to the list head structure
elmPointer to the entry to be inserted
fieldName of the list entry field (declared using AST_LIST_ENTRY())
sortfieldName of the field on which the list is sorted
Since
1.6.1

Definition at line 751 of file linkedlists.h.

◆ AST_LIST_INSERT_TAIL

#define AST_LIST_INSERT_TAIL (   head,
  elm,
  field 
)

Appends a list entry to the tail of a list.

Parameters
headThis is a pointer to the list head structure
elmThis is a pointer to the entry to be appended.
fieldThis is the name of the field (declared using AST_LIST_ENTRY()) used to link entries of this list together.

Note: The link field in the appended entry is not modified, so if it is actually the head of a list itself, the entire list will be appended temporarily (until the next AST_LIST_INSERT_TAIL is performed).

Definition at line 731 of file linkedlists.h.

◆ AST_LIST_LAST

#define AST_LIST_LAST (   head)    ((head)->last)

Returns the last entry contained in a list.

Parameters
headThis is a pointer to the list head structure

Definition at line 429 of file linkedlists.h.

◆ AST_LIST_LOCK

#define AST_LIST_LOCK (   head)     ast_mutex_lock(&(head)->lock)

Locks a list.

Parameters
headThis is a pointer to the list head structure

This macro attempts to place an exclusive lock in the list head structure pointed to by head.

Return values
0on success
non-zeroon failure

Definition at line 40 of file linkedlists.h.

◆ AST_LIST_MOVE_CURRENT

#define AST_LIST_MOVE_CURRENT (   newhead,
  field 
)
Value:
do { \
typeof ((newhead)->first) __extracted = __list_current; \
AST_LIST_REMOVE_CURRENT(field); \
AST_LIST_INSERT_TAIL((newhead), __extracted, field); \
} while (0)

Move the current list entry to another list.

Note
This is a silly macro. It should be done explicitly otherwise the field parameter must be the same for the two lists.

AST_LIST_REMOVE_CURRENT(field); AST_LIST_INSERT_TAIL(newhead, var, other_field);

Definition at line 582 of file linkedlists.h.

◆ AST_LIST_NEXT

#define AST_LIST_NEXT (   elm,
  field 
)    ((elm)->field.next)

Returns the next entry in the list after the given entry.

Parameters
elmThis is a pointer to the current entry.
fieldThis is the name of the field (declared using AST_LIST_ENTRY()) used to link entries of this list together.

Definition at line 439 of file linkedlists.h.

◆ AST_LIST_REMOVE

#define AST_LIST_REMOVE (   head,
  elm,
  field 
)

Removes a specific entry from a list.

Parameters
headThis is a pointer to the list head structure
elmThis is a pointer to the entry to be removed.
fieldThis is the name of the field (declared using AST_LIST_ENTRY()) used to link entries of this list together.
Return values
elmif elm was in the list.
NULLif elm was not in the list or elm was NULL.
Warning
The removed entry is not freed.

Definition at line 856 of file linkedlists.h.

◆ AST_LIST_REMOVE_CURRENT

#define AST_LIST_REMOVE_CURRENT (   field)

Removes the current entry from a list during a traversal.

Parameters
fieldThis is the name of the field (declared using AST_LIST_ENTRY()) used to link entries of this list together.
Note
This macro can only be used inside an AST_LIST_TRAVERSE_SAFE_BEGIN() block; it is used to unlink the current entry from the list without affecting the list traversal (and without having to re-traverse the list to modify the previous entry, if any).

Definition at line 557 of file linkedlists.h.

◆ AST_LIST_REMOVE_HEAD

#define AST_LIST_REMOVE_HEAD (   head,
  field 
)

Removes and returns the head entry from a list.

Parameters
headThis is a pointer to the list head structure
fieldThis is the name of the field (declared using AST_LIST_ENTRY()) used to link entries of this list together.

Removes the head entry from the list, and returns a pointer to it. This macro is safe to call on an empty list.

Definition at line 833 of file linkedlists.h.

◆ AST_LIST_TRAVERSE

#define AST_LIST_TRAVERSE (   head,
  var,
  field 
)     for((var) = (head)->first; (var); (var) = (var)->field.next)

Loops over (traverses) the entries in a list.

Parameters
headThis is a pointer to the list head structure
varThis is the name of the variable that will hold a pointer to the current list entry on each iteration. It must be declared before calling this macro.
fieldThis is the name of the field (declared using AST_LIST_ENTRY()) used to link entries of this list together.

This macro is use to loop over (traverse) the entries in a list. It uses a for loop, and supplies the enclosed code with a pointer to each list entry as it loops. It is typically used as follows:

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)
}
size_t current
Definition: main/cli.c:113
Warning
If you modify the forward-link pointer contained in the current entry while inside the loop, the behavior will be unpredictable. At a minimum, the following macros will modify the forward-link pointer, and should not be used inside AST_LIST_TRAVERSE() against the entry pointed to by the current pointer without careful consideration of their consequences:

Definition at line 491 of file linkedlists.h.

◆ AST_LIST_TRAVERSE_SAFE_BEGIN

#define AST_LIST_TRAVERSE_SAFE_BEGIN (   head,
  var,
  field 
)

Loops safely over (traverses) the entries in a list.

Parameters
headThis is a pointer to the list head structure
varThis is the name of the variable that will hold a pointer to the current list entry on each iteration. It must be declared before calling this macro.
fieldThis is the name of the field (declared using AST_LIST_ENTRY()) used to link entries of this list together.

This macro is used to safely loop over (traverse) the entries in a list. It uses a for loop, and supplies the enclosed code with a pointer to each list entry as it loops. It is typically used as follows:

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_SAFE_BEGIN(&entries, current, list) {
(do something with current here)
}
#define AST_LIST_TRAVERSE_SAFE_END
Closes a safe loop traversal block.
Definition: linkedlists.h:615

It differs from AST_LIST_TRAVERSE() in that the code inside the loop can modify (or even free, after calling AST_LIST_REMOVE_CURRENT()) the entry pointed to by the current pointer without affecting the loop traversal.

Definition at line 529 of file linkedlists.h.

◆ AST_LIST_TRAVERSE_SAFE_END

#define AST_LIST_TRAVERSE_SAFE_END   }

Closes a safe loop traversal block.

Definition at line 615 of file linkedlists.h.

◆ AST_LIST_TRYLOCK

#define AST_LIST_TRYLOCK (   head)     ast_mutex_trylock(&(head)->lock)

Locks a list, without blocking if the list is locked.

Parameters
headThis is a pointer to the list head structure

This macro attempts to place an exclusive lock in the list head structure pointed to by head.

Return values
0on success
non-zeroon failure

Definition at line 105 of file linkedlists.h.

◆ AST_LIST_UNLOCK

#define AST_LIST_UNLOCK (   head)     ast_mutex_unlock(&(head)->lock)

Attempts to unlock a list.

Parameters
headThis is a pointer to the list head structure

This macro attempts to remove an exclusive lock from the list head structure pointed to by head. If the list was not locked by this thread, this macro has no effect.

Definition at line 140 of file linkedlists.h.

◆ AST_RWLIST_APPEND_LIST

#define AST_RWLIST_APPEND_LIST   AST_LIST_APPEND_LIST

Definition at line 798 of file linkedlists.h.

◆ AST_RWLIST_EMPTY

#define AST_RWLIST_EMPTY   AST_LIST_EMPTY

Definition at line 452 of file linkedlists.h.

◆ AST_RWLIST_ENTRY

#define AST_RWLIST_ENTRY   AST_LIST_ENTRY

Definition at line 415 of file linkedlists.h.

◆ AST_RWLIST_FIRST

#define AST_RWLIST_FIRST   AST_LIST_FIRST

Definition at line 423 of file linkedlists.h.

◆ AST_RWLIST_HEAD

#define AST_RWLIST_HEAD (   name,
  type 
)
Value:
struct name { \
struct type *first; \
struct type *last; \
ast_rwlock_t lock; \
}

Defines a structure to be used to hold a read/write list of specified type.

Parameters
nameThis will be the name of the defined structure.
typeThis is the type of each list entry.

This macro creates a structure definition that can be used to hold a list of the entries of type type. It does not actually declare (allocate) a structure; to do that, either follow this macro with the desired name of the instance you wish to declare, or use the specified name to declare instances elsewhere.

Example usage:

static AST_RWLIST_HEAD(entry_list, entry) entries;
#define AST_RWLIST_HEAD(name, type)
Defines a structure to be used to hold a read/write list of specified type.
Definition: linkedlists.h:199

This would define struct entry_list, and declare an instance of it named entries, all intended to hold a list of type struct entry.

Definition at line 199 of file linkedlists.h.

◆ AST_RWLIST_HEAD_DESTROY

#define AST_RWLIST_HEAD_DESTROY (   head)
Value:
{ \
(head)->first = NULL; \
(head)->last = NULL; \
ast_rwlock_destroy(&(head)->lock); \
}

Destroys an rwlist head structure.

Parameters
headThis is a pointer to the list head structure

This macro destroys a list head structure by setting the head entry to NULL (empty list) and destroying the embedded lock. It does not free the structure from memory.

Definition at line 667 of file linkedlists.h.

◆ AST_RWLIST_HEAD_INIT

#define AST_RWLIST_HEAD_INIT (   head)
Value:
{ \
(head)->first = NULL; \
(head)->last = NULL; \
ast_rwlock_init(&(head)->lock); \
}

Initializes an rwlist head structure.

Parameters
headThis is a pointer to the list head structure

This macro initializes a list head structure by setting the head entry to NULL (empty list) and recreating the embedded lock.

Definition at line 639 of file linkedlists.h.

◆ AST_RWLIST_HEAD_INIT_VALUE

#define AST_RWLIST_HEAD_INIT_VALUE
Value:
{ \
.first = NULL, \
.last = NULL, \
}
#define AST_RWLOCK_INIT_VALUE
Definition: lock.h:98

Defines initial values for a declaration of AST_RWLIST_HEAD.

Definition at line 243 of file linkedlists.h.

◆ AST_RWLIST_HEAD_SET

#define AST_RWLIST_HEAD_SET (   head,
  entry 
)
Value:
do { \
(head)->first = (entry); \
(head)->last = (entry); \
ast_rwlock_init(&(head)->lock); \
} while (0)

Initializes an rwlist head structure with a specified first entry.

Parameters
headThis is a pointer to the list head structure
entrypointer to the list entry that will become the head of the list

This macro initializes a list head structure by setting the head entry to the supplied value and recreating the embedded lock.

Definition at line 374 of file linkedlists.h.

◆ AST_RWLIST_HEAD_STATIC

#define AST_RWLIST_HEAD_STATIC (   name,
  type 
)
Value:
struct name { \
struct type *first; \
struct type *last; \
ast_rwlock_t lock; \
#define AST_RWLIST_HEAD_INIT_VALUE
Defines initial values for a declaration of AST_RWLIST_HEAD.
Definition: linkedlists.h:243

Defines a structure to be used to hold a read/write list of specified type, statically initialized.

Parameters
nameThis will be the name of the defined structure.
typeThis is the type of each list entry.

This macro creates a structure definition that can be used to hold a list of the entries of type type, and allocates an instance of it, initialized to be empty.

Example usage:

#define AST_RWLIST_HEAD_STATIC(name, type)
Defines a structure to be used to hold a read/write list of specified type, statically initialized.
Definition: linkedlists.h:333

This would define struct entry_list, intended to hold a list of type struct entry.

Definition at line 333 of file linkedlists.h.

◆ AST_RWLIST_INSERT_AFTER

#define AST_RWLIST_INSERT_AFTER   AST_LIST_INSERT_AFTER

Definition at line 702 of file linkedlists.h.

◆ AST_RWLIST_INSERT_BEFORE_CURRENT

#define AST_RWLIST_INSERT_BEFORE_CURRENT   AST_LIST_INSERT_BEFORE_CURRENT

Definition at line 610 of file linkedlists.h.

◆ AST_RWLIST_INSERT_HEAD

#define AST_RWLIST_INSERT_HEAD   AST_LIST_INSERT_HEAD

Definition at line 718 of file linkedlists.h.

◆ AST_RWLIST_INSERT_LIST_AFTER

#define AST_RWLIST_INSERT_LIST_AFTER   AST_LIST_INSERT_LIST_AFTER

Definition at line 822 of file linkedlists.h.

◆ AST_RWLIST_INSERT_SORTALPHA

#define AST_RWLIST_INSERT_SORTALPHA   AST_LIST_INSERT_SORTALPHA

Definition at line 771 of file linkedlists.h.

◆ AST_RWLIST_INSERT_TAIL

#define AST_RWLIST_INSERT_TAIL   AST_LIST_INSERT_TAIL

Definition at line 741 of file linkedlists.h.

◆ AST_RWLIST_LAST

#define AST_RWLIST_LAST   AST_LIST_LAST

Definition at line 431 of file linkedlists.h.

◆ AST_RWLIST_MOVE_CURRENT

#define AST_RWLIST_MOVE_CURRENT   AST_LIST_MOVE_CURRENT

Definition at line 588 of file linkedlists.h.

◆ AST_RWLIST_NEXT

#define AST_RWLIST_NEXT   AST_LIST_NEXT

Definition at line 441 of file linkedlists.h.

◆ AST_RWLIST_RDLOCK

#define AST_RWLIST_RDLOCK (   head)     ast_rwlock_rdlock(&(head)->lock)

Read locks a list.

Parameters
headThis is a pointer to the list head structure

This macro attempts to place a read lock in the list head structure pointed to by head.

Return values
0on success
non-zeroon failure

Definition at line 78 of file linkedlists.h.

◆ AST_RWLIST_REMOVE

#define AST_RWLIST_REMOVE   AST_LIST_REMOVE

Definition at line 885 of file linkedlists.h.

◆ AST_RWLIST_REMOVE_CURRENT

#define AST_RWLIST_REMOVE_CURRENT   AST_LIST_REMOVE_CURRENT

Definition at line 570 of file linkedlists.h.

◆ AST_RWLIST_REMOVE_HEAD

#define AST_RWLIST_REMOVE_HEAD   AST_LIST_REMOVE_HEAD

Definition at line 844 of file linkedlists.h.

◆ AST_RWLIST_TIMEDRDLOCK

#define AST_RWLIST_TIMEDRDLOCK (   head,
  ts 
)     ast_rwlock_timedrdlock(&(head)->lock, ts)

Read locks a list, with timeout.

Parameters
headThis is a pointer to the list head structure
tsPointer to a timespec structure

This macro attempts to place a read lock in the list head structure pointed to by head.

Return values
0on success
non-zeroon failure
Since
1.6.1

Definition at line 93 of file linkedlists.h.

◆ AST_RWLIST_TIMEDWRLOCK

#define AST_RWLIST_TIMEDWRLOCK (   head,
  ts 
)    ast_rwlock_timedwrlock(&(head)->lock, ts)

Write locks a list, with timeout.

Parameters
headThis is a pointer to the list head structure
tsPointer to a timespec structure

This macro attempts to place an exclusive write lock in the list head structure pointed to by head.

Return values
0on success
non-zeroon failure
Since
1.6.1

Definition at line 67 of file linkedlists.h.

◆ AST_RWLIST_TRAVERSE

#define AST_RWLIST_TRAVERSE   AST_LIST_TRAVERSE

Definition at line 494 of file linkedlists.h.

◆ AST_RWLIST_TRAVERSE_SAFE_BEGIN

#define AST_RWLIST_TRAVERSE_SAFE_BEGIN   AST_LIST_TRAVERSE_SAFE_BEGIN

Definition at line 545 of file linkedlists.h.

◆ AST_RWLIST_TRAVERSE_SAFE_END

#define AST_RWLIST_TRAVERSE_SAFE_END   AST_LIST_TRAVERSE_SAFE_END

Definition at line 617 of file linkedlists.h.

◆ AST_RWLIST_TRYRDLOCK

#define AST_RWLIST_TRYRDLOCK (   head)     ast_rwlock_tryrdlock(&(head)->lock)

Read locks a list, without blocking if the list is locked.

Parameters
headThis is a pointer to the list head structure

This macro attempts to place a read lock in the list head structure pointed to by head.

Return values
0on success
non-zeroon failure

Definition at line 129 of file linkedlists.h.

◆ AST_RWLIST_TRYWRLOCK

#define AST_RWLIST_TRYWRLOCK (   head)     ast_rwlock_trywrlock(&(head)->lock)

Write locks a list, without blocking if the list is locked.

Parameters
headThis is a pointer to the list head structure

This macro attempts to place an exclusive write lock in the list head structure pointed to by head.

Return values
0on success
non-zeroon failure

Definition at line 117 of file linkedlists.h.

◆ AST_RWLIST_UNLOCK

#define AST_RWLIST_UNLOCK (   head)     ast_rwlock_unlock(&(head)->lock)

Attempts to unlock a read/write based list.

Parameters
headThis is a pointer to the list head structure

This macro attempts to remove a read or write lock from the list head structure pointed to by head. If the list was not locked by this thread, this macro has no effect.

Definition at line 151 of file linkedlists.h.

◆ AST_RWLIST_WRLOCK

#define AST_RWLIST_WRLOCK (   head)     ast_rwlock_wrlock(&(head)->lock)

Write locks a list.

Parameters
headThis is a pointer to the list head structure

This macro attempts to place an exclusive write lock in the list head structure pointed to by head.

Return values
0on success
non-zeroon failure

Definition at line 52 of file linkedlists.h.