VSF Documented
Data Structures | Macros | Functions
vsf_list.h File Reference
#include "../compiler/compiler.h"

Go to the source code of this file.

Data Structures

struct  vsf_slist_t
 
struct  vsf_slist_node_t
 
struct  vsf_dlist_t
 
struct  vsf_dlist_node_t
 
struct  vsf_slist_queue_t
 

Macros

#define __vsf_when(__cond)   (__cond)
 
#define vsf_when(__cond)   __vsf_when(__cond)
 
#define __vsf_list_tmp_name(__head)   VSF_MCONNECT2(__head, __LINE__)
 
#define __vsf_slist_is_empty(__list_ptr)    (NULL == ((vsf_slist_t *)(__list_ptr))->head)
 
#define __vsf_slist_set_next(__node_ptr, __item_next_ptr)
 
#define __vsf_slist_ref_next(__node_ptr, __item_ref_ptr)
 
#define __vsf_slist_insert_next(__host_type, __member, __node_ptr, __item_ptr)
 
#define __vsf_slist_remove_next_unsafe(__host_type, __member, __node_ptr, __item_ref_ptr)
 
#define __vsf_slist_insert_after( __host_type, __member, __item_ptr, __item_new_ptr)
 
#define __vsf_slist_remove_after( __host_type, __member, __item_ptr, __item_ref_ptr)
 
#define __vsf_slist_insert( __host_type, __member, __list_ptr, __item_ptr, __cond)
 
#define __vsf_slist_foreach_unsafe( __host_type, __member, __list_ptr)
 
#define __vsf_slist_foreach_next_unsafe( __host_type, __member, __list_ptr)
 
#define __vsf_slist_foreach(__host_type, __member, __list_ptr, __item_ptr)
 
#define __vsf_slist_discard_head(__host_type, __member, __list_ptr)
 
#define __vsf_slist_queue_init(__queue_ptr)
 
#define __vsf_slist_queue_enqueue(__host_type, __member, __queue_ptr, __item_ptr)
 
#define __vsf_slist_queue_dequeue( __host_type, __member, __queue_ptr, __item_ref_ptr)
 
#define __vsf_slist_queue_is_in(__host_type, __member, __queue_ptr, __item_ptr)    vsf_slist_is_in(__host_type, __member, (vsf_slist_t *)&(__queue_ptr)->head, (__item_ptr))
 
#define __vsf_slist_queue_peek(__host_type, __member, __queue_ptr, __item_ref_ptr)    __vsf_slist_ref_next(&((__queue_ptr)->head), (__item_ref_ptr));
 
#define __vsf_slist_queue_add_to_head( __host_type, __member, __queue_ptr, __item_ptr)
 
#define __vsf_dlist_init(__list_ptr)
 
#define __vsf_dlist_init_node(__node_ptr)
 
#define __vsf_dlist_get_host(__host_type, __member, __node_ptr)    vsf_container_of((__node_ptr), __host_type, __member)
 
#define __vsf_dlist_get_host_safe(__host_type, __member, __node_ptr)    vsf_safe_container_of((__node_ptr), __host_type, __member)
 
#define __vsf_dlist_is_empty(__list_ptr)   ((__list_ptr)->head == NULL)
 
#define __vsf_dlist_is_in(__list_ptr, __node_ptr)    __vsf_dlist_is_in_imp((__list_ptr), (__node_ptr))
 
#define __vsf_dlist_ref(__host_type, __member, __node_ptr, __item_ref_ptr)
 
#define __vsf_dlist_ref_safe(__host_type, __member, __node_ptr, __item_ref_ptr)
 
#define __vsf_dlist_add_to_head(__host_type, __member, __list_ptr, __item_ptr)    __vsf_dlist_add_to_head_imp((__list_ptr), &((__item_ptr)->__member))
 
#define __vsf_dlist_add_to_tail(__host_type, __member, __list_ptr, __item_ptr)    __vsf_dlist_add_to_tail_imp((__list_ptr), &((__item_ptr)->__member))
 
#define __vsf_dlist_peek_next(__host_type, __member, __item_ptr, __item_ref_ptr)
 
#define __vsf_dlist_peek_head(__host_type, __member, __list_ptr, __item_ref_ptr)
 
#define __vsf_dlist_remove_head(__host_type, __member, __list_ptr, __item_ref_ptr)
 
#define __vsf_dlist_remove_tail(__host_type, __member, __list_ptr, __item_ref_ptr)
 
#define __vsf_dlist_insert_after( __host_type, __member, __list_ptr, __item_prv_ptr, __item_ptr)
 
#define __vsf_dlist_insert_before( __host_type, __member, __list_ptr, __item_next_ptr, __item_ptr)
 
#define __vsf_dlist_remove(__host_type, __member, __list_ptr, __item_ptr)    __vsf_dlist_remove_imp((__list_ptr), &((__item_ptr)->__member))
 
#define __vsf_dlist_remove_after( __host_type, __member, __list_ptr, __node_ptr, __item_ref_ptr)
 
#define __vsf_dlist_remove_before( __host_type, __member, __list_ptr, __node_ptr, __item_ref_ptr)
 
#define __vsf_dlist_insert( __host_type, __member, __list_ptr, __item_ptr, __cond)
 
#define __vsf_dlist_foreach_unsafe( __host_type, __member, __list_ptr)
 
#define __vsf_dlist_foreach_next_unsafe( __host_type, __member, __list_ptr)
 
list normal access
#define vsf_slist_init(__list_ptr)
 
#define vsf_slist_is_empty(__list_ptr)
 
#define vsf_slist_set_next(__host_type, __member, __node_ptr, __item_ptr)
 
#define vsf_slist_get_length( __host_type, __member, __list_ptr)
 
#define vsf_slist_remove_tail( __host_type, __member, __list_ptr)
 
#define vsf_slist_get_item_by_index( __host_type, __member, __list_ptr, __index)
 
#define vsf_slist_get_index( __host_type, __member, __list_ptr, __item_ptr)
 
#define vsf_slist_append( __host_type, __member, __list_ptr, __item_ptr)
 
#define vsf_slist_is_in( __host_type, __member, __list_ptr, __item_ptr)
 
#define vsf_slist_init_node(__host_type, __member, __item_ptr)
 
#define vsf_slist_remove( __host_type, __member, __list_ptr, __item_ptr)
 
#define vsf_slist_insert(__host_type, __member, __list_ptr, __item_ptr, __cond)
 
#define vsf_slist_remove_after(__host_type, __member, __item_ptr, __item_ref_ptr)
 
#define vsf_slist_insert_after(__host_type, __member, __item_ptr, __item_new_ptr)
 
stack / stack-like operations using list
#define vsf_slist_stack_init(__list_ptr)   vsf_slist_init_node(__list_ptr)
 
#define vsf_slist_stack_pop(__host_type, __member, __list_ptr, __item_ref_ptr)
 
#define vsf_slist_stack_push( __host_type, __member, __list_ptr, __item_ptr)
 
#define vsf_slist_add_to_head( __host_type, __member, __list_ptr, __item_ptr)
 
#define vsf_slist_discard_head(__host_type, __member, __list_ptr)
 
#define vsf_slist_remove_from_head_unsafe( __host_type, __member, __list_ptr, __item_ref_ptr)
 
#define vsf_slist_remove_from_head( __host_type, __member, __list_ptr, __item_ref_ptr)
 
#define vsf_slist_remove_head   vsf_slist_remove_from_head
 
#define vsf_slist_peek_next(__host_type, __member, __node_ptr, __item_ref_ptr)
 
list enumeration access
#define vsf_slist_foreach( __host_type, __member, __list_ptr, __item_ptr)
 
queue / queue-like operations using slist
#define vsf_slist_queue_is_empty(__queue_ptr)    vsf_slist_is_empty(&(__queue_ptr)->head)
 
#define vsf_slist_queue_init(__queue_ptr)    __vsf_slist_queue_init((__queue_ptr))/* the address of the queue */
 
#define vsf_slist_queue_enqueue(__host_type, __member, __queue_ptr, __item_ptr)
 
#define vsf_slist_queue_dequeue(__host_type, __member, __queue_ptr, __item_ref_ptr)
 
#define vsf_slist_queue_is_in( __host_type, __member, __queue_ptr, __item_ptr)
 
#define vsf_slist_queue_peek( __host_type, __member, __queue_ptr, __item_ref_ptr)
 
#define vsf_slist_queue_add_to_head( __host_type, __member, __queue_ptr, __item_ptr)
 
dual-way linked list normal access
#define vsf_dlist_init(__list_ptr)
 
#define vsf_dlist_is_empty(__list_ptr)
 
#define vsf_dlist_get_length( __list_ptr)
 
#define vsf_dlist_is_in( __host_type, __member, __list_ptr, __item_ptr)
 
#define vsf_dlist_init_node( __host_type, __member, __item_ptr)
 
#define vsf_dlist_add_to_head( __host_type, __member, __list_ptr, __item_ptr)
 
#define vsf_dlist_add_to_tail( __host_type, __member, __list_ptr, __item_ptr)
 
#define vsf_dlist_peek_head( __host_type, __member, __list_ptr, __item_ref_ptr)
 
#define vsf_dlist_peek_next( __host_type, __member, __item_ptr, __item_ref_ptr)
 
#define vsf_dlist_remove_head( __host_type, __member, __list_ptr, __item_ref_ptr)
 
#define vsf_dlist_remove_tail( __host_type, __member, __list_ptr, __item_ref_ptr)
 
#define vsf_dlist_insert( __host_type, __member, __list_ptr, __item_ptr, __cond)
 
#define vsf_dlist_insert_after(__host_type, __member, __list_ptr, __item_prv_ptr, __item_ptr)
 
#define vsf_dlist_insert_before(__host_type, __member, __list_ptr, __item_next_ptr, __item_ptr)
 
#define vsf_dlist_remove( __host_type, __member, __list_ptr, __item_ptr)
 
#define vsf_dlist_remove_after(__host_type, __member, __list_ptr, __node_ptr, __item_ref_ptr)
 
#define vsf_dlist_remove_before(__host_type, __member, __list_ptr, __node_ptr, __item_ref_ptr)
 
queue operation using dual-way linked list
#define vsf_dlist_queue_peek( __host_type, __member, __list_ptr, __item_ref_ptr)
 
#define vsf_dlist_queue_enqueue(__host_type, __member, __list_ptr, __item_ptr)
 
#define vsf_dlist_queue_dequeue(__host_type, __member, __list_ptr, __item_ref_ptr)
 

Typedefs

single list item
typedef struct vsf_slist_t vsf_slist_t
 
typedef struct vsf_slist_node_t vsf_slist_node_t
 
dual-way linked list item
typedef struct vsf_dlist_t vsf_dlist_t
 
typedef struct vsf_dlist_node_t vsf_dlist_node_t
 
single list queue header
typedef struct vsf_slist_queue_t vsf_slist_queue_t
 

Functions

uint_fast16_t __vsf_slist_get_length_imp (vsf_slist_t *this_ptr, size_t list_offset)
 calculate the length of the target list !
 
void * __vsf_slist_get_item_by_index_imp (vsf_slist_t *this_ptr, uint_fast16_t index, size_t list_offset)
 get the specified item with a given index from the target list !
 
int_fast16_t __vsf_slist_get_index_imp (vsf_slist_t *this_ptr, void *item, size_t list_offset)
 find the index number of a given item from the target list !
 
void * __vsf_slist_remove_imp (vsf_slist_t *this_ptr, void *item, size_t list_offset)
 remove a item from the target list !
 
void * __vsf_slist_append_imp (vsf_slist_t *this_ptr, void *item, size_t list_offset)
 append a item from the target list !
 
void * __vsf_slist_remove_tail_imp (vsf_slist_t *this_ptr, size_t list_offset)
 
uint_fast16_t __vsf_dlist_get_length_imp (vsf_dlist_t *this_ptr)
 
bool __vsf_dlist_is_in_imp (vsf_dlist_t *this_ptr, vsf_dlist_node_t *node)
 
void __vsf_dlist_add_to_head_imp (vsf_dlist_t *this_ptr, vsf_dlist_node_t *node)
 
void __vsf_dlist_add_to_tail_imp (vsf_dlist_t *this_ptr, vsf_dlist_node_t *node)
 
vsf_dlist_node_t * __vsf_dlist_remove_head_imp (vsf_dlist_t *this_ptr)
 
vsf_dlist_node_t * __vsf_dlist_remove_tail_imp (vsf_dlist_t *this_ptr)
 
void __vsf_dlist_insert_after_imp (vsf_dlist_t *this_ptr, vsf_dlist_node_t *node_prv, vsf_dlist_node_t *node)
 
void __vsf_dlist_insert_before_imp (vsf_dlist_t *this_ptr, vsf_dlist_node_t *node_nxt, vsf_dlist_node_t *node)
 
void __vsf_dlist_remove_imp (vsf_dlist_t *this_ptr, vsf_dlist_node_t *node)
 

Macro Definition Documentation

◆ __vsf_when

#define __vsf_when (   __cond)    (__cond)

◆ vsf_when

#define vsf_when (   __cond)    __vsf_when(__cond)

◆ __vsf_list_tmp_name

#define __vsf_list_tmp_name (   __head)    VSF_MCONNECT2(__head, __LINE__)

◆ __vsf_slist_is_empty

#define __vsf_slist_is_empty (   __list_ptr)     (NULL == ((vsf_slist_t *)(__list_ptr))->head)

◆ __vsf_slist_set_next

#define __vsf_slist_set_next (   __node_ptr,
  __item_next_ptr 
)
Value:
do { \
((vsf_slist_node_t *)(__node_ptr))->next = (__item_next_ptr); \
} while (0)
vsf_slist_node_t
Definition vsf_list.h:876
next
vsf_msgt_node_offset_t next
Definition vsf_msg_tree.h:192

◆ __vsf_slist_ref_next

#define __vsf_slist_ref_next (   __node_ptr,
  __item_ref_ptr 
)
Value:
do { \
(*(void **)&(__item_ref_ptr)) = \
(((vsf_slist_node_t *)(__node_ptr))->next); \
} while (0)

◆ __vsf_slist_insert_next

#define __vsf_slist_insert_next (   __host_type,
  __member,
  __node_ptr,
  __item_ptr 
)
Value:
do { \
__vsf_slist_set_next(&((__item_ptr)->__member), ((__node_ptr)->next)); \
__vsf_slist_set_next((__node_ptr), (__item_ptr)); \
} while (0)

◆ __vsf_slist_remove_next_unsafe

#define __vsf_slist_remove_next_unsafe (   __host_type,
  __member,
  __node_ptr,
  __item_ref_ptr 
)
Value:
do { \
__vsf_slist_ref_next((__node_ptr), (__item_ref_ptr)); \
__vsf_slist_set_next((__node_ptr), \
((__host_type *)(__item_ref_ptr))->__member.next); \
} while (0)

◆ __vsf_slist_insert_after

#define __vsf_slist_insert_after (   __host_type,
  __member,
  __item_ptr,
  __item_new_ptr 
)
Value:
/* new item address */ \
do { \
vsf_slist_node_t *__vsf_list_tmp_name(node) = &((__item_ptr)->__member);\
__vsf_slist_insert_next(__host_type, __member, \
__vsf_list_tmp_name(node), (__item_new_ptr)); \
} while (0)
__vsf_list_tmp_name
#define __vsf_list_tmp_name(__head)
Definition vsf_list.h:38

◆ __vsf_slist_remove_after

#define __vsf_slist_remove_after (   __host_type,
  __member,
  __item_ptr,
  __item_ref_ptr 
)
Value:
/* pointer of host type*/ \
do { \
vsf_slist_node_t *__vsf_list_tmp_name(node) = &((__item_ptr)->__member);\
__vsf_slist_ref_next(__vsf_list_tmp_name(node), (__item_ref_ptr)); \
if (NULL != __vsf_list_tmp_name(node)->next) { \
__vsf_slist_set_next(__vsf_list_tmp_name(node), \
((__host_type *)(__vsf_list_tmp_name(node)->next))->__member.next);\
__vsf_slist_set_next(&((__item_ref_ptr)->__member), NULL); \
} \
} while (0)
NULL
#define NULL
Definition lvgl.h:26

◆ __vsf_slist_insert

#define __vsf_slist_insert (   __host_type,
  __member,
  __list_ptr,
  __item_ptr,
  __cond 
)
Value:
/* how to find insert point */ \
do { \
vsf_slist_node_t *__vsf_list_tmp_name(node) = \
(vsf_slist_node_t *)(__list_ptr); \
vsf_slist_init_node(__host_type, __member, __item_ptr); \
for (; __vsf_list_tmp_name(node)->next != NULL;){ \
const __host_type * const _ = \
(__host_type *)(__vsf_list_tmp_name(node)->next); \
/* using __VA_ARGS__ so ',' operation could be supported */ \
if (__cond) { \
__vsf_slist_insert_next(__host_type, __member, \
__vsf_list_tmp_name(node), (__item_ptr)); \
break; \
} \
__vsf_list_tmp_name(node) = (vsf_slist_node_t *)&(_->__member); \
} \
if (NULL == __vsf_list_tmp_name(node)->next) { \
__vsf_slist_insert_next(__host_type, __member, \
__vsf_list_tmp_name(node), (__item_ptr)); \
break; \
} \
} while (0)
_
struct @749::@768 _

◆ __vsf_slist_foreach_unsafe

#define __vsf_slist_foreach_unsafe (   __host_type,
  __member,
  __list_ptr 
)
Value:
/* the address of the list */ \
for ( __host_type *_ = (__host_type *)((__list_ptr)->head); \
_ != NULL; \
_ = (__host_type *)(_->__member.next))
head
uint16_t head
Definition vsf_queue.h:632

◆ __vsf_slist_foreach_next_unsafe

#define __vsf_slist_foreach_next_unsafe (   __host_type,
  __member,
  __list_ptr 
)
Value:
/* the address of the list */ \
for ( __host_type *_ = (__host_type *)((__list_ptr)->head), \
*__ = _ ? (__host_type *)(_->__member.next) : NULL; \
_ != NULL; \
_ = __, __ = _ ? (__host_type *)(_->__member.next) : NULL)

◆ __vsf_slist_foreach

#define __vsf_slist_foreach (   __host_type,
  __member,
  __list_ptr,
  __item_ptr 
)
Value:
/* the pointer name, e.g. ptarget */\
for (__host_type /* loop initialisation */ \
*__item_ptr = (__host_type *)(__list_ptr)->head, \
*_ = __item_ptr, \
*next = __item_ptr \
? (__host_type *) \
((__host_type *)((__list_ptr)->head))->__member.next \
: NULL; \
__item_ptr != NULL; /* loop condition */ \
_ = __item_ptr = next, next = __item_ptr \
? (__host_type *) \
((__host_type *)((__list_ptr)->head))->__member.next \
: NULL) /* prepare for next iteration */

◆ __vsf_slist_discard_head

#define __vsf_slist_discard_head (   __host_type,
  __member,
  __list_ptr 
)
Value:
if (NULL != (__list_ptr)->head) { \
__host_type *item = (__host_type *)((__list_ptr)->head); \
__vsf_slist_set_next( \
(__list_ptr), \
((__host_type *)((__list_ptr)->head))->__member.next); \
item->__member.next = NULL; \
}

◆ __vsf_slist_queue_init

#define __vsf_slist_queue_init (   __queue_ptr)
Value:
do { \
__vsf_slist_set_next(&((__queue_ptr)->head), NULL); \
__vsf_slist_set_next(&((__queue_ptr)->tail), NULL); \
} while (0)
tail
uint16_t tail
Definition vsf_queue.h:632

◆ __vsf_slist_queue_enqueue

#define __vsf_slist_queue_enqueue (   __host_type,
  __member,
  __queue_ptr,
  __item_ptr 
)
Value:
do { \
__host_type * __vsf_list_tmp_name(host_tail) = \
(__host_type *)((__queue_ptr)->tail.next); \
__vsf_slist_set_next(&((__queue_ptr)->tail), (__item_ptr)); \
if (__vsf_list_tmp_name(host_tail) != NULL) \
__vsf_slist_set_next(&__vsf_list_tmp_name(host_tail)->__member, (__item_ptr));\
else \
__vsf_slist_set_next(&((__queue_ptr)->head), (__item_ptr)); \
} while (0)

◆ __vsf_slist_queue_dequeue

#define __vsf_slist_queue_dequeue (   __host_type,
  __member,
  __queue_ptr,
  __item_ref_ptr 
)
Value:
do { \
__vsf_slist_ref_next(&((__queue_ptr)->head), (__item_ref_ptr)); \
if (NULL != (__item_ref_ptr)) { \
__vsf_slist_set_next( \
&((__queue_ptr)->head), \
(__item_ref_ptr)->__member.next); \
if (__vsf_slist_is_empty(&((__queue_ptr)->head))) \
__vsf_slist_set_next(&((__queue_ptr)->tail), NULL); \
__vsf_slist_set_next(&((__item_ref_ptr)->__member), NULL); \
} \
} while (0)
__vsf_slist_is_empty
#define __vsf_slist_is_empty(__list_ptr)
Definition vsf_list.h:44

◆ __vsf_slist_queue_is_in

#define __vsf_slist_queue_is_in (   __host_type,
  __member,
  __queue_ptr,
  __item_ptr 
)     vsf_slist_is_in(__host_type, __member, (vsf_slist_t *)&(__queue_ptr)->head, (__item_ptr))

◆ __vsf_slist_queue_peek

#define __vsf_slist_queue_peek (   __host_type,
  __member,
  __queue_ptr,
  __item_ref_ptr 
)     __vsf_slist_ref_next(&((__queue_ptr)->head), (__item_ref_ptr));

◆ __vsf_slist_queue_add_to_head

#define __vsf_slist_queue_add_to_head (   __host_type,
  __member,
  __queue_ptr,
  __item_ptr 
)
Value:
do { \
__host_type * __vsf_list_tmp_name(host_head) = \
(__host_type *)((__queue_ptr)->head.next); \
__vsf_slist_set_next(&(__item_ptr)->__member, \
__vsf_list_tmp_name(host_head)); \
__vsf_slist_set_next(&((__queue_ptr)->head), (__item_ptr)); \
if (NULL == __vsf_list_tmp_name(host_head)) \
__vsf_slist_set_next(&((__queue_ptr)->tail), (__item_ptr)); \
} while (0)

◆ __vsf_dlist_init

#define __vsf_dlist_init (   __list_ptr)
Value:
do { \
(__list_ptr)->head = (__list_ptr)->tail = NULL; \
} while (0)

◆ __vsf_dlist_init_node

#define __vsf_dlist_init_node (   __node_ptr)
Value:
do { \
(__node_ptr)->next = (__node_ptr)->prev = NULL; \
} while (0)

◆ __vsf_dlist_get_host

#define __vsf_dlist_get_host (   __host_type,
  __member,
  __node_ptr 
)     vsf_container_of((__node_ptr), __host_type, __member)

◆ __vsf_dlist_get_host_safe

#define __vsf_dlist_get_host_safe (   __host_type,
  __member,
  __node_ptr 
)     vsf_safe_container_of((__node_ptr), __host_type, __member)

◆ __vsf_dlist_is_empty

#define __vsf_dlist_is_empty (   __list_ptr)    ((__list_ptr)->head == NULL)

◆ __vsf_dlist_is_in

#define __vsf_dlist_is_in (   __list_ptr,
  __node_ptr 
)     __vsf_dlist_is_in_imp((__list_ptr), (__node_ptr))

◆ __vsf_dlist_ref

#define __vsf_dlist_ref (   __host_type,
  __member,
  __node_ptr,
  __item_ref_ptr 
)
Value:
do { \
(*(__host_type **)&(__item_ref_ptr)) = \
__vsf_dlist_get_host(__host_type, __member, __node_ptr); \
} while (0)
__vsf_dlist_get_host
#define __vsf_dlist_get_host(__host_type, __member, __node_ptr)
Definition vsf_list.h:271

◆ __vsf_dlist_ref_safe

#define __vsf_dlist_ref_safe (   __host_type,
  __member,
  __node_ptr,
  __item_ref_ptr 
)
Value:
do { \
(*(__host_type **)&(__item_ref_ptr)) = \
__vsf_dlist_get_host_safe(__host_type, __member, __node_ptr); \
} while (0)
__vsf_dlist_get_host_safe
#define __vsf_dlist_get_host_safe(__host_type, __member, __node_ptr)
Definition vsf_list.h:274

◆ __vsf_dlist_add_to_head

#define __vsf_dlist_add_to_head (   __host_type,
  __member,
  __list_ptr,
  __item_ptr 
)     __vsf_dlist_add_to_head_imp((__list_ptr), &((__item_ptr)->__member))

◆ __vsf_dlist_add_to_tail

#define __vsf_dlist_add_to_tail (   __host_type,
  __member,
  __list_ptr,
  __item_ptr 
)     __vsf_dlist_add_to_tail_imp((__list_ptr), &((__item_ptr)->__member))

◆ __vsf_dlist_peek_next

#define __vsf_dlist_peek_next (   __host_type,
  __member,
  __item_ptr,
  __item_ref_ptr 
)
Value:
do { \
vsf_dlist_node_t *__vsf_list_tmp_name(node) = (__item_ptr)->__member.next;\
__vsf_dlist_ref_safe(__host_type, __member, \
__vsf_list_tmp_name(node), (__item_ref_ptr)); \
} while (0)
vsf_dlist_node_t
Definition vsf_list.h:888
vsf_dlist_node_t::next
struct vsf_dlist_node_t * next
Definition vsf_list.h:889

◆ __vsf_dlist_peek_head

#define __vsf_dlist_peek_head (   __host_type,
  __member,
  __list_ptr,
  __item_ref_ptr 
)
Value:
do { \
vsf_dlist_node_t *__vsf_list_tmp_name(node) = (__list_ptr)->head; \
__vsf_dlist_ref_safe(__host_type, __member, \
__vsf_list_tmp_name(node), (__item_ref_ptr)); \
} while (0)

◆ __vsf_dlist_remove_head

#define __vsf_dlist_remove_head (   __host_type,
  __member,
  __list_ptr,
  __item_ref_ptr 
)
Value:
do { \
vsf_dlist_node_t *__vsf_list_tmp_name(node) = \
__vsf_dlist_remove_head_imp(__list_ptr); \
__vsf_dlist_ref_safe(__host_type, __member, \
__vsf_list_tmp_name(node), (__item_ref_ptr)); \
} while (0)

◆ __vsf_dlist_remove_tail

#define __vsf_dlist_remove_tail (   __host_type,
  __member,
  __list_ptr,
  __item_ref_ptr 
)
Value:
do { \
vsf_dlist_node_t *__vsf_list_tmp_name(node) = \
__vsf_dlist_remove_tail_imp(__list_ptr); \
__vsf_dlist_ref_safe(__host_type, __member, \
__vsf_list_tmp_name(node), (__item_ref_ptr)); \
} while (0)

◆ __vsf_dlist_insert_after

#define __vsf_dlist_insert_after (   __host_type,
  __member,
  __list_ptr,
  __item_prv_ptr,
  __item_ptr 
)
Value:
__vsf_dlist_insert_after_imp( \
(__list_ptr), \
&((__item_prv_ptr)->__member), \
&((__item_ptr)->__member))
__vsf_dlist_insert_after_imp
void __vsf_dlist_insert_after_imp(vsf_dlist_t *this_ptr, vsf_dlist_node_t *node_prv, vsf_dlist_node_t *node)
Definition vsf_list.c:258

◆ __vsf_dlist_insert_before

#define __vsf_dlist_insert_before (   __host_type,
  __member,
  __list_ptr,
  __item_next_ptr,
  __item_ptr 
)
Value:
__vsf_dlist_insert_before_imp( \
(__list_ptr), \
&((__item_next_ptr)->__member), \
&((__item_ptr)->__member))
__vsf_dlist_insert_before_imp
void __vsf_dlist_insert_before_imp(vsf_dlist_t *this_ptr, vsf_dlist_node_t *node_nxt, vsf_dlist_node_t *node)
Definition vsf_list.c:274

◆ __vsf_dlist_remove

#define __vsf_dlist_remove (   __host_type,
  __member,
  __list_ptr,
  __item_ptr 
)     __vsf_dlist_remove_imp((__list_ptr), &((__item_ptr)->__member))

◆ __vsf_dlist_remove_after

#define __vsf_dlist_remove_after (   __host_type,
  __member,
  __list_ptr,
  __node_ptr,
  __item_ref_ptr 
)
Value:
do { \
vsf_dlist_node_t *__vsf_list_tmp_name(node_nxt) = (__node_ptr)->next; \
if (__vsf_list_tmp_name(node_nxt) != NULL) { \
__vsf_dlist_remove(__host_type, __member, __list_ptr, \
__vsf_list_tmp_name(node_nxt)); \
__vsf_dlist_ref(__host_type, __member, \
__vsf_list_tmp_name(node_nxt), (__item_ref_ptr)); \
} else { \
(*(__host_type **)&(__item_ref_ptr)) = NULL; \
} \
} while (0)

◆ __vsf_dlist_remove_before

#define __vsf_dlist_remove_before (   __host_type,
  __member,
  __list_ptr,
  __node_ptr,
  __item_ref_ptr 
)
Value:
do { \
vsf_dlist_node_t *__vsf_list_tmp_name(node_prv) = (__node_ptr)->prev; \
if (__vsf_list_tmp_name(node_prv) != NULL) { \
__vsf_dlist_remove(__host_type, __member, __list_ptr, \
__vsf_list_tmp_name(node_prv)); \
__vsf_dlist_ref(__host_type, __member, \
__vsf_list_tmp_name(node_prv), (__item_ref_ptr)); \
} else { \
(*(__host_type **)&(__item_ref_ptr)) = NULL; \
} \
} while (0)

◆ __vsf_dlist_insert

#define __vsf_dlist_insert (   __host_type,
  __member,
  __list_ptr,
  __item_ptr,
  __cond 
)
Value:
/* how to find insert point */ \
do { \
vsf_dlist_node_t *__vsf_list_tmp_name(node) = \
(vsf_dlist_node_t *)(__list_ptr); \
vsf_dlist_init_node(__host_type, __member, __item_ptr); \
for (; __vsf_list_tmp_name(node)->next != NULL;){ \
const __host_type * const _ = __vsf_dlist_get_host(__host_type, \
__member, __vsf_list_tmp_name(node)->next); \
/* using __VA_ARGS__ so ',' operation could be supported */ \
if (__cond) { \
__vsf_dlist_insert_before_imp((__list_ptr), \
__vsf_list_tmp_name(node)->next, &((__item_ptr)->__member));\
break; \
} \
__vsf_list_tmp_name(node) = __vsf_list_tmp_name(node)->next; \
} \
if (NULL == __vsf_list_tmp_name(node)->next) { \
__vsf_dlist_add_to_tail( \
__host_type, __member, __list_ptr, (__item_ptr)); \
} \
} while (0)

◆ __vsf_dlist_foreach_unsafe

#define __vsf_dlist_foreach_unsafe (   __host_type,
  __member,
  __list_ptr 
)
Value:
/* the address of the list */ \
for ( __host_type *_ = NULL == (__list_ptr)->head ? NULL : \
__vsf_dlist_get_host(__host_type, __member, (__list_ptr)->head);\
_ != NULL; \
_ = NULL == _->__member.next ? NULL : \
__vsf_dlist_get_host(__host_type, __member, _->__member.next))

◆ __vsf_dlist_foreach_next_unsafe

#define __vsf_dlist_foreach_next_unsafe (   __host_type,
  __member,
  __list_ptr 
)
Value:
/* the address of the list */ \
for ( __host_type \
*_ = NULL == (__list_ptr)->head ? NULL : \
__vsf_dlist_get_host(__host_type, __member, (__list_ptr)->head),\
*__ = (NULL == _ || NULL == _->__member.next) ? NULL : \
__vsf_dlist_get_host(__host_type, __member, _->__member.next);\
_ != NULL; \
_ = __, __ = (NULL == _ || NULL == _->__member.next) ? NULL : \
__vsf_dlist_get_host(__host_type, __member, _->__member.next))

◆ vsf_slist_init

#define vsf_slist_init (   __list_ptr)
Value:
/* the address of the list */ \
__vsf_slist_set_next((__list_ptr), NULL)

◆ vsf_slist_is_empty

#define vsf_slist_is_empty (   __list_ptr)
Value:
/* the address of the list */ \
__vsf_slist_is_empty(__list_ptr)

◆ vsf_slist_set_next

#define vsf_slist_set_next (   __host_type,
  __member,
  __node_ptr,
  __item_ptr 
)
Value:
/* the address of the target item */\
__vsf_slist_set_next((__node_ptr), (__item_ptr))

◆ vsf_slist_get_length

#define vsf_slist_get_length (   __host_type,
  __member,
  __list_ptr 
)
Value:
/* the address of the list */ \
__vsf_slist_get_length_imp( \
(__list_ptr), vsf_offset_of(__host_type, __member))
vsf_offset_of
#define vsf_offset_of(__type, __member)
Definition __type.h:162

◆ vsf_slist_remove_tail

#define vsf_slist_remove_tail (   __host_type,
  __member,
  __list_ptr 
)
Value:
/* the address of the list */ \
__vsf_slist_remove_tail_imp( \
(__list_ptr), vsf_offset_of(__host_type, __member))

◆ vsf_slist_get_item_by_index

#define vsf_slist_get_item_by_index (   __host_type,
  __member,
  __list_ptr,
  __index 
)
Value:
/* index of the item in list */ \
__vsf_slist_get_item_by_index_imp( \
(__list_ptr), (__index), vsf_offset_of(__host_type, __member))

◆ vsf_slist_get_index

#define vsf_slist_get_index (   __host_type,
  __member,
  __list_ptr,
  __item_ptr 
)
Value:
/* the address of the target item */\
__vsf_slist_get_index_imp( \
(__list_ptr), (__item_ptr), vsf_offset_of(__host_type, __member))

◆ vsf_slist_append

#define vsf_slist_append (   __host_type,
  __member,
  __list_ptr,
  __item_ptr 
)
Value:
/* the address of the target item */\
__vsf_slist_append_imp( \
(__list_ptr), (__item_ptr), vsf_offset_of(__host_type, __member))

◆ vsf_slist_is_in

#define vsf_slist_is_in (   __host_type,
  __member,
  __list_ptr,
  __item_ptr 
)
Value:
/* the address of the target item */\
( vsf_slist_get_index( \
__host_type, __member, (__list_ptr), (__item_ptr)) \
>= 0)
vsf_slist_get_index
#define vsf_slist_get_index( __host_type, __member, __list_ptr, __item_ptr)
Definition vsf_list.h:497

◆ vsf_slist_init_node

#define vsf_slist_init_node (   __host_type,
  __member,
  __item_ptr 
)
Value:
/* the address of the target item */\
__vsf_slist_set_next(&((__item_ptr)->__member), NULL)

◆ vsf_slist_remove

#define vsf_slist_remove (   __host_type,
  __member,
  __list_ptr,
  __item_ptr 
)
Value:
/* the address of the target item */\
__vsf_slist_remove_imp( \
(__list_ptr), (__item_ptr), vsf_offset_of(__host_type, __member))

◆ vsf_slist_insert

#define vsf_slist_insert (   __host_type,
  __member,
  __list_ptr,
  __item_ptr,
  __cond 
)
Value:
/* when( condition expression ) */ \
__vsf_slist_insert( \
__host_type, __member, (__list_ptr), (__item_ptr), (__cond))

◆ vsf_slist_remove_after

#define vsf_slist_remove_after (   __host_type,
  __member,
  __item_ptr,
  __item_ref_ptr 
)
Value:
/* the pointer of host type */ \
__vsf_slist_remove_after( \
__host_type, __member, (__item_ptr), (__item_ref_ptr))

◆ vsf_slist_insert_after

#define vsf_slist_insert_after (   __host_type,
  __member,
  __item_ptr,
  __item_new_ptr 
)
Value:
/* the address of new item */ \
__vsf_slist_insert_after( \
__host_type, __member, (__item_ptr), (__item_new_ptr))

◆ vsf_slist_stack_init

#define vsf_slist_stack_init (   __list_ptr)    vsf_slist_init_node(__list_ptr)

◆ vsf_slist_stack_pop

#define vsf_slist_stack_pop (   __host_type,
  __member,
  __list_ptr,
  __item_ref_ptr 
)
Value:
/* the pointer of host type */ \
vsf_slist_remove_from_head( \
__host_type, __member, (__list_ptr), (__item_ref_ptr))

◆ vsf_slist_stack_push

#define vsf_slist_stack_push (   __host_type,
  __member,
  __list_ptr,
  __item_ptr 
)
Value:
/* the address of the target item */\
vsf_slist_add_to_head( \
__host_type, __member, (__list_ptr), (__item_ptr))

◆ vsf_slist_add_to_head

#define vsf_slist_add_to_head (   __host_type,
  __member,
  __list_ptr,
  __item_ptr 
)
Value:
/* the address of the target item */\
__vsf_slist_insert_next( \
__host_type, \
__member, \
(vsf_slist_node_t *)(__list_ptr), \
(__item_ptr))

◆ vsf_slist_discard_head

#define vsf_slist_discard_head (   __host_type,
  __member,
  __list_ptr 
)
Value:
/* the address of the list */ \
__vsf_slist_discard_head(__host_type, __member, (__list_ptr))

◆ vsf_slist_remove_from_head_unsafe

#define vsf_slist_remove_from_head_unsafe (   __host_type,
  __member,
  __list_ptr,
  __item_ref_ptr 
)
Value:
/* the pointer of host type */ \
__vsf_slist_remove_next_unsafe( \
__host_type, \
__member, \
(vsf_slist_node_t *)(__list_ptr), \
(__item_ref_ptr))

◆ vsf_slist_remove_from_head

#define vsf_slist_remove_from_head (   __host_type,
  __member,
  __list_ptr,
  __item_ref_ptr 
)
Value:
/* the pointer of host type */ \
do { \
vsf_slist_peek_next(__host_type, __member, (__list_ptr), (__item_ref_ptr));\
vsf_slist_discard_head(__host_type, __member, (__list_ptr)); \
} while (0)

◆ vsf_slist_remove_head

#define vsf_slist_remove_head   vsf_slist_remove_from_head

◆ vsf_slist_peek_next

#define vsf_slist_peek_next (   __host_type,
  __member,
  __node_ptr,
  __item_ref_ptr 
)
Value:
/* the pointer of host type */ \
__vsf_slist_ref_next((__node_ptr), (__item_ref_ptr))

◆ vsf_slist_foreach

#define vsf_slist_foreach (   __host_type,
  __member,
  __list_ptr,
  __item_ptr 
)
Value:
/* the pointer name, e.g. ptarget */\
__vsf_slist_foreach(__host_type, __member, (__list_ptr), __item_ptr)

◆ vsf_slist_queue_is_empty

#define vsf_slist_queue_is_empty (   __queue_ptr)     vsf_slist_is_empty(&(__queue_ptr)->head)

◆ vsf_slist_queue_init

#define vsf_slist_queue_init (   __queue_ptr)     __vsf_slist_queue_init((__queue_ptr))/* the address of the queue */

◆ vsf_slist_queue_enqueue

#define vsf_slist_queue_enqueue (   __host_type,
  __member,
  __queue_ptr,
  __item_ptr 
)
Value:
/* the address of the target item */\
__vsf_slist_queue_enqueue( \
__host_type, __member, (__queue_ptr), (__item_ptr))

◆ vsf_slist_queue_dequeue

#define vsf_slist_queue_dequeue (   __host_type,
  __member,
  __queue_ptr,
  __item_ref_ptr 
)
Value:
/* the pointer of host type */ \
__vsf_slist_queue_dequeue( \
__host_type, __member, (__queue_ptr), (__item_ref_ptr))

◆ vsf_slist_queue_is_in

#define vsf_slist_queue_is_in (   __host_type,
  __member,
  __queue_ptr,
  __item_ptr 
)
Value:
/* the address of the target item */\
__vsf_slist_queue_is_in( \
__host_type, __member, (__queue_ptr), (__item_ptr))

◆ vsf_slist_queue_peek

#define vsf_slist_queue_peek (   __host_type,
  __member,
  __queue_ptr,
  __item_ref_ptr 
)
Value:
/* the pointer of host type */ \
__vsf_slist_queue_peek( \
__host_type, __member, (__queue_ptr), (__item_ref_ptr))

◆ vsf_slist_queue_add_to_head

#define vsf_slist_queue_add_to_head (   __host_type,
  __member,
  __queue_ptr,
  __item_ptr 
)
Value:
/* the address of the target item */\
__vsf_slist_queue_add_to_head( \
__host_type, __member, (__queue_ptr), (__item_ptr))

◆ vsf_dlist_init

#define vsf_dlist_init (   __list_ptr)
Value:
/* the address of the list */ \
__vsf_dlist_init(__list_ptr)

◆ vsf_dlist_is_empty

#define vsf_dlist_is_empty (   __list_ptr)
Value:
/* the address of the list */ \
__vsf_dlist_is_empty(__list_ptr)

◆ vsf_dlist_get_length

#define vsf_dlist_get_length (   __list_ptr)
Value:
/* the address of the list */ \
__vsf_dlist_get_length_imp(__list_ptr)

◆ vsf_dlist_is_in

#define vsf_dlist_is_in (   __host_type,
  __member,
  __list_ptr,
  __item_ptr 
)
Value:
/* the address of the target item */\
__vsf_dlist_is_in((__list_ptr), &(__item_ptr)->__member)

◆ vsf_dlist_init_node

#define vsf_dlist_init_node (   __host_type,
  __member,
  __item_ptr 
)
Value:
/* the address of the target item */\
__vsf_dlist_init_node(&((__item_ptr)->__member))

◆ vsf_dlist_add_to_head

#define vsf_dlist_add_to_head (   __host_type,
  __member,
  __list_ptr,
  __item_ptr 
)
Value:
/* the address of the target item */\
__vsf_dlist_add_to_head(__host_type, \
__member, \
(__list_ptr), \
(__item_ptr))

◆ vsf_dlist_add_to_tail

#define vsf_dlist_add_to_tail (   __host_type,
  __member,
  __list_ptr,
  __item_ptr 
)
Value:
/* the address of the target item */\
__vsf_dlist_add_to_tail(__host_type, \
__member, \
(__list_ptr), \
(__item_ptr))

◆ vsf_dlist_peek_head

#define vsf_dlist_peek_head (   __host_type,
  __member,
  __list_ptr,
  __item_ref_ptr 
)
Value:
/* the pointer of host type */ \
__vsf_dlist_peek_head( \
__host_type, __member, (__list_ptr), (__item_ref_ptr))

◆ vsf_dlist_peek_next

#define vsf_dlist_peek_next (   __host_type,
  __member,
  __item_ptr,
  __item_ref_ptr 
)
Value:
/* the pointer of host type */ \
__vsf_dlist_peek_next( \
__host_type, __member, (__item_ptr), (__item_ref_ptr))

◆ vsf_dlist_remove_head

#define vsf_dlist_remove_head (   __host_type,
  __member,
  __list_ptr,
  __item_ref_ptr 
)
Value:
/* the pointer of host type */ \
__vsf_dlist_remove_head( \
__host_type, __member, (__list_ptr), (__item_ref_ptr))

◆ vsf_dlist_remove_tail

#define vsf_dlist_remove_tail (   __host_type,
  __member,
  __list_ptr,
  __item_ref_ptr 
)
Value:
/* the pointer of host type */ \
__vsf_dlist_remove_tail( \
__host_type, __member, (__list_ptr), (__item_ref_ptr))

◆ vsf_dlist_insert

#define vsf_dlist_insert (   __host_type,
  __member,
  __list_ptr,
  __item_ptr,
  __cond 
)
Value:
/* when( condition expression ) */ \
__vsf_dlist_insert( \
__host_type, __member, (__list_ptr), (__item_ptr), (__cond))

◆ vsf_dlist_insert_after

#define vsf_dlist_insert_after (   __host_type,
  __member,
  __list_ptr,
  __item_prv_ptr,
  __item_ptr 
)
Value:
/* the address of the target item */\
__vsf_dlist_insert_after( \
__host_type, \
__member, \
(__list_ptr), \
(__item_prv_ptr), \
(__item_ptr))

◆ vsf_dlist_insert_before

#define vsf_dlist_insert_before (   __host_type,
  __member,
  __list_ptr,
  __item_next_ptr,
  __item_ptr 
)
Value:
/* the address of the target item */\
__vsf_dlist_insert_before( \
__host_type, \
__member, \
(__list_ptr), \
(__item_next_ptr), \
(__item_ptr))

◆ vsf_dlist_remove

#define vsf_dlist_remove (   __host_type,
  __member,
  __list_ptr,
  __item_ptr 
)
Value:
/* the address of the target item */\
__vsf_dlist_remove(__host_type, __member, (__list_ptr), (__item_ptr))

◆ vsf_dlist_remove_after

#define vsf_dlist_remove_after (   __host_type,
  __member,
  __list_ptr,
  __node_ptr,
  __item_ref_ptr 
)
Value:
/* the pointer of host type */ \
__vsf_dlist_remove_after( \
__host_type, \
__member, \
(__list_ptr), \
(__node_ptr), \
(__item_ref_ptr))

◆ vsf_dlist_remove_before

#define vsf_dlist_remove_before (   __host_type,
  __member,
  __list_ptr,
  __node_ptr,
  __item_ref_ptr 
)
Value:
/* the pointer of host type */ \
__vsf_dlist_remove_before( \
__host_type, \
__member, \
(__list_ptr), \
(__node_ptr), \
(__item_ref_ptr))

◆ vsf_dlist_queue_peek

#define vsf_dlist_queue_peek (   __host_type,
  __member,
  __list_ptr,
  __item_ref_ptr 
)
Value:
/* the pointer of host type */ \
__vsf_dlist_ref_safe( \
__host_type, __member, (__list_ptr)->head, (__item_ref_ptr))

◆ vsf_dlist_queue_enqueue

#define vsf_dlist_queue_enqueue (   __host_type,
  __member,
  __list_ptr,
  __item_ptr 
)
Value:
/* the address of the target item */\
vsf_dlist_add_to_tail( \
__host_type, __member, (__list_ptr), (__item_ptr))

◆ vsf_dlist_queue_dequeue

#define vsf_dlist_queue_dequeue (   __host_type,
  __member,
  __list_ptr,
  __item_ref_ptr 
)
Value:
/* the address of the target item */\
vsf_dlist_remove_head( \
__host_type, __member, (__list_ptr), (__item_ref_ptr))

Typedef Documentation

◆ vsf_slist_t

typedef struct vsf_slist_t vsf_slist_t

◆ vsf_slist_node_t

typedef struct vsf_slist_node_t vsf_slist_node_t

◆ vsf_dlist_t

typedef struct vsf_dlist_t vsf_dlist_t

◆ vsf_dlist_node_t

typedef struct vsf_dlist_node_t vsf_dlist_node_t

◆ vsf_slist_queue_t

typedef struct vsf_slist_queue_t vsf_slist_queue_t

Function Documentation

◆ __vsf_slist_get_length_imp()

uint_fast16_t __vsf_slist_get_length_imp ( vsf_slist_t *  this_ptr,
size_t  list_offset 
)
extern

calculate the length of the target list !

Parameters
this_ptraddress of the target list !
list_offsetthe list offset in byte within a host type !
Returns
the length of the list, -1 means illegal input
Parameters
this_ptraddress of the target list !
list_offsetthe list offset in byte within a host type !
Returns
the length of the list

◆ __vsf_slist_get_item_by_index_imp()

void * __vsf_slist_get_item_by_index_imp ( vsf_slist_t *  this_ptr,
uint_fast16_t  index,
size_t  list_offset 
)
extern

get the specified item with a given index from the target list !

Parameters
this_ptraddress of the target list !
indexindex number of the wanted item !
list_offsetthe list offset in byte within a host type !
Return values
NULLIllegal input !
!NULLthe address of the wanted item

◆ __vsf_slist_get_index_imp()

int_fast16_t __vsf_slist_get_index_imp ( vsf_slist_t *  this_ptr,
void *  item,
size_t  list_offset 
)
extern

find the index number of a given item from the target list !

Parameters
this_ptraddress of the target list !
itemaddress of the target item !
list_offsetthe list offset in byte within a host type !
Returns
the index number, (-1) means illegal input or the item doesn't exist

◆ __vsf_slist_remove_imp()

void * __vsf_slist_remove_imp ( vsf_slist_t *  this_ptr,
void *  item,
size_t  list_offset 
)
extern

remove a item from the target list !

Parameters
this_ptraddress of the target list !
itemaddress of the target item !
list_offsetthe list offset in byte within a host type !
Return values
NULLIllegal input !
!NULLthe address of the removed item

remove the target item

cut the item off from the list

◆ __vsf_slist_append_imp()

void * __vsf_slist_append_imp ( vsf_slist_t *  this_ptr,
void *  item,
size_t  list_offset 
)
extern

append a item from the target list !

Parameters
this_ptraddress of the target list !
itemaddress of the target item !
list_offsetthe list offset in byte within a host type !
Return values
NULLIllegal input !
!NULLthe address of the appended item

append a item from the target list !

Parameters
this_ptraddress of the target list !
itemaddress of the target item !
list_offsetthe list offset in byte within a host type !
Return values
NULLIllegal input !
!NULLthe address of the appended item

< append the item

◆ __vsf_slist_remove_tail_imp()

void * __vsf_slist_remove_tail_imp ( vsf_slist_t *  this_ptr,
size_t  list_offset 
)
extern

◆ __vsf_dlist_get_length_imp()

uint_fast16_t __vsf_dlist_get_length_imp ( vsf_dlist_t *  this_ptr)
extern

◆ __vsf_dlist_is_in_imp()

bool __vsf_dlist_is_in_imp ( vsf_dlist_t *  this_ptr,
vsf_dlist_node_t *  node 
)
extern

◆ __vsf_dlist_add_to_head_imp()

void __vsf_dlist_add_to_head_imp ( vsf_dlist_t *  this_ptr,
vsf_dlist_node_t *  node 
)
extern

◆ __vsf_dlist_add_to_tail_imp()

void __vsf_dlist_add_to_tail_imp ( vsf_dlist_t *  this_ptr,
vsf_dlist_node_t *  node 
)
extern

◆ __vsf_dlist_remove_head_imp()

vsf_dlist_node_t * __vsf_dlist_remove_head_imp ( vsf_dlist_t *  this_ptr)
extern

◆ __vsf_dlist_remove_tail_imp()

vsf_dlist_node_t * __vsf_dlist_remove_tail_imp ( vsf_dlist_t *  this_ptr)
extern

◆ __vsf_dlist_insert_after_imp()

void __vsf_dlist_insert_after_imp ( vsf_dlist_t *  this_ptr,
vsf_dlist_node_t *  node_prv,
vsf_dlist_node_t *  node 
)
extern

◆ __vsf_dlist_insert_before_imp()

void __vsf_dlist_insert_before_imp ( vsf_dlist_t *  this_ptr,
vsf_dlist_node_t *  node_nxt,
vsf_dlist_node_t *  node 
)
extern

◆ __vsf_dlist_remove_imp()

void __vsf_dlist_remove_imp ( vsf_dlist_t *  this_ptr,
vsf_dlist_node_t *  node 
)
extern
Generated by doxygen 1.9.8