ref: b4ff1f9ca24fa7ca7d89000cbd1402d120b0054e
src/libs/mynewt-nimble/nimble/host/mesh/include/mesh/slist.h
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 |
/* * Copyright (c) 2016 Intel Corporation * * SPDX-License-Identifier: Apache-2.0 */ /** * @file * * @brief Single-linked list implementation * * Single-linked list implementation using inline macros/functions. * This API is not thread safe, and thus if a list is used across threads, * calls to functions must be protected with synchronization primitives. */ #ifndef __SLIST_H__ #define __SLIST_H__ #include <stddef.h> #include <stdbool.h> #ifdef __cplusplus extern "C" { #endif struct _snode { struct _snode *next; }; typedef struct _snode sys_snode_t; struct _slist { sys_snode_t *head; sys_snode_t *tail; }; typedef struct _slist sys_slist_t; /** * @brief Provide the primitive to iterate on a list * Note: the loop is unsafe and thus __sn should not be removed * * User _MUST_ add the loop statement curly braces enclosing its own code: * * SYS_SLIST_FOR_EACH_NODE(l, n) { * <user code> * } * * This and other SYS_SLIST_*() macros are not thread safe. * * @param __sl A pointer on a sys_slist_t to iterate on * @param __sn A sys_snode_t pointer to peek each node of the list */ #define SYS_SLIST_FOR_EACH_NODE(__sl, __sn) \ for (__sn = sys_slist_peek_head(__sl); __sn; \ __sn = sys_slist_peek_next(__sn)) /** * @brief Provide the primitive to iterate on a list, from a node in the list * Note: the loop is unsafe and thus __sn should not be removed * * User _MUST_ add the loop statement curly braces enclosing its own code: * * SYS_SLIST_ITERATE_FROM_NODE(l, n) { * <user code> * } * * Like SYS_SLIST_FOR_EACH_NODE(), but __dn already contains a node in the list * where to start searching for the next entry from. If NULL, it starts from * the head. * * This and other SYS_SLIST_*() macros are not thread safe. * * @param __sl A pointer on a sys_slist_t to iterate on * @param __sn A sys_snode_t pointer to peek each node of the list * it contains the starting node, or NULL to start from the head */ #define SYS_SLIST_ITERATE_FROM_NODE(__sl, __sn) \ for (__sn = __sn ? sys_slist_peek_next_no_check(__sn) \ : sys_slist_peek_head(__sl); \ __sn; \ __sn = sys_slist_peek_next(__sn)) /** * @brief Provide the primitive to safely iterate on a list * Note: __sn can be removed, it will not break the loop. * * User _MUST_ add the loop statement curly braces enclosing its own code: * * SYS_SLIST_FOR_EACH_NODE_SAFE(l, n, s) { * <user code> * } * * This and other SYS_SLIST_*() macros are not thread safe. * * @param __sl A pointer on a sys_slist_t to iterate on * @param __sn A sys_snode_t pointer to peek each node of the list * @param __sns A sys_snode_t pointer for the loop to run safely */ #define SYS_SLIST_FOR_EACH_NODE_SAFE(__sl, __sn, __sns) \ for (__sn = sys_slist_peek_head(__sl), \ __sns = sys_slist_peek_next(__sn); \ __sn; __sn = __sns, \ __sns = sys_slist_peek_next(__sn)) /* * @brief Provide the primitive to resolve the container of a list node * Note: it is safe to use with NULL pointer nodes * * @param __ln A pointer on a sys_node_t to get its container * @param __cn Container struct type pointer * @param __n The field name of sys_node_t within the container struct */ #define SYS_SLIST_CONTAINER(__ln, __cn, __n) \ ((__ln) ? CONTAINER_OF((__ln), __typeof__(*(__cn)), __n) : NULL) /* * @brief Provide the primitive to peek container of the list head * * @param __sl A pointer on a sys_slist_t to peek * @param __cn Container struct type pointer * @param __n The field name of sys_node_t within the container struct */ #define SYS_SLIST_PEEK_HEAD_CONTAINER(__sl, __cn, __n) \ SYS_SLIST_CONTAINER(sys_slist_peek_head(__sl), __cn, __n) /* * @brief Provide the primitive to peek container of the list tail * * @param __sl A pointer on a sys_slist_t to peek * @param __cn Container struct type pointer * @param __n The field name of sys_node_t within the container struct */ #define SYS_SLIST_PEEK_TAIL_CONTAINER(__sl, __cn, __n) \ SYS_SLIST_CONTAINER(sys_slist_peek_tail(__sl), __cn, __n) /* * @brief Provide the primitive to peek the next container * * @param __cn Container struct type pointer * @param __n The field name of sys_node_t within the container struct */ #define SYS_SLIST_PEEK_NEXT_CONTAINER(__cn, __n) \ ((__cn) ? SYS_SLIST_CONTAINER(sys_slist_peek_next(&((__cn)->__n)), \ __cn, __n) : NULL) /** * @brief Provide the primitive to iterate on a list under a container * Note: the loop is unsafe and thus __cn should not be detached * * User _MUST_ add the loop statement curly braces enclosing its own code: * * SYS_SLIST_FOR_EACH_CONTAINER(l, c, n) { * <user code> * } * * @param __sl A pointer on a sys_slist_t to iterate on * @param __cn A pointer to peek each entry of the list * @param __n The field name of sys_node_t within the container struct */ #define SYS_SLIST_FOR_EACH_CONTAINER(__sl, __cn, __n) \ for (__cn = SYS_SLIST_PEEK_HEAD_CONTAINER(__sl, __cn, __n); __cn; \ __cn = SYS_SLIST_PEEK_NEXT_CONTAINER(__cn, __n)) /** * @brief Provide the primitive to safely iterate on a list under a container * Note: __cn can be detached, it will not break the loop. * * User _MUST_ add the loop statement curly braces enclosing its own code: * * SYS_SLIST_FOR_EACH_NODE_SAFE(l, c, cn, n) { * <user code> * } * * @param __sl A pointer on a sys_slist_t to iterate on * @param __cn A pointer to peek each entry of the list * @param __cns A pointer for the loop to run safely * @param __n The field name of sys_node_t within the container struct */ #define SYS_SLIST_FOR_EACH_CONTAINER_SAFE(__sl, __cn, __cns, __n) \ for (__cn = SYS_SLIST_PEEK_HEAD_CONTAINER(__sl, __cn, __n), \ __cns = SYS_SLIST_PEEK_NEXT_CONTAINER(__cn, __n); __cn; \ __cn = __cns, __cns = SYS_SLIST_PEEK_NEXT_CONTAINER(__cn, __n)) /** * @brief Initialize a list * * @param list A pointer on the list to initialize */ static inline void sys_slist_init(sys_slist_t *list) { list->head = NULL; list->tail = NULL; } #define SYS_SLIST_STATIC_INIT(ptr_to_list) {NULL, NULL} /** * @brief Test if the given list is empty * * @param list A pointer on the list to test * * @return a boolean, true if it's empty, false otherwise */ static inline bool sys_slist_is_empty(sys_slist_t *list) { return (!list->head); } /** * @brief Peek the first node from the list * * @param list A point on the list to peek the first node from * * @return A pointer on the first node of the list (or NULL if none) */ static inline sys_snode_t *sys_slist_peek_head(sys_slist_t *list) { return list->head; } /** * @brief Peek the last node from the list * * @param list A point on the list to peek the last node from * * @return A pointer on the last node of the list (or NULL if none) */ static inline sys_snode_t *sys_slist_peek_tail(sys_slist_t *list) { return list->tail; } /** * @brief Peek the next node from current node, node is not NULL * * Faster then sys_slist_peek_next() if node is known not to be NULL. * * @param node A pointer on the node where to peek the next node * * @return a pointer on the next node (or NULL if none) */ static inline sys_snode_t *sys_slist_peek_next_no_check(sys_snode_t *node) { return node->next; } /** * @brief Peek the next node from current node * * @param node A pointer on the node where to peek the next node * * @return a pointer on the next node (or NULL if none) */ static inline sys_snode_t *sys_slist_peek_next(sys_snode_t *node) { return node ? sys_slist_peek_next_no_check(node) : NULL; } /** * @brief Prepend a node to the given list * * This and other sys_slist_*() functions are not thread safe. * * @param list A pointer on the list to affect * @param node A pointer on the node to prepend */ static inline void sys_slist_prepend(sys_slist_t *list, sys_snode_t *node) { node->next = list->head; list->head = node; if (!list->tail) { list->tail = list->head; } } /** * @brief Append a node to the given list * * This and other sys_slist_*() functions are not thread safe. * * @param list A pointer on the list to affect * @param node A pointer on the node to append */ static inline void sys_slist_append(sys_slist_t *list, sys_snode_t *node) { node->next = NULL; if (!list->tail) { list->tail = node; list->head = node; } else { list->tail->next = node; list->tail = node; } } /** * @brief Append a list to the given list * * Append a singly-linked, NULL-terminated list consisting of nodes containing * the pointer to the next node as the first element of a node, to @a list. * This and other sys_slist_*() functions are not thread safe. * * @param list A pointer on the list to affect * @param head A pointer to the first element of the list to append * @param tail A pointer to the last element of the list to append */ static inline void sys_slist_append_list(sys_slist_t *list, void *head, void *tail) { if (!list->tail) { list->head = (sys_snode_t *)head; list->tail = (sys_snode_t *)tail; } else { list->tail->next = (sys_snode_t *)head; list->tail = (sys_snode_t *)tail; } } /** * @brief merge two slists, appending the second one to the first * * When the operation is completed, the appending list is empty. * This and other sys_slist_*() functions are not thread safe. * * @param list A pointer on the list to affect * @param list_to_append A pointer to the list to append. */ static inline void sys_slist_merge_slist(sys_slist_t *list, sys_slist_t *list_to_append) { sys_slist_append_list(list, list_to_append->head, list_to_append->tail); sys_slist_init(list_to_append); } /** * @brief Insert a node to the given list * * This and other sys_slist_*() functions are not thread safe. * * @param list A pointer on the list to affect * @param prev A pointer on the previous node * @param node A pointer on the node to insert */ static inline void sys_slist_insert(sys_slist_t *list, sys_snode_t *prev, sys_snode_t *node) { if (!prev) { sys_slist_prepend(list, node); } else if (!prev->next) { sys_slist_append(list, node); } else { node->next = prev->next; prev->next = node; } } /** * @brief Fetch and remove the first node of the given list * * List must be known to be non-empty. * This and other sys_slist_*() functions are not thread safe. * * @param list A pointer on the list to affect * * @return A pointer to the first node of the list */ static inline sys_snode_t *sys_slist_get_not_empty(sys_slist_t *list) { sys_snode_t *node = list->head; list->head = node->next; if (list->tail == node) { list->tail = list->head; } return node; } /** * @brief Fetch and remove the first node of the given list * * This and other sys_slist_*() functions are not thread safe. * * @param list A pointer on the list to affect * * @return A pointer to the first node of the list (or NULL if empty) */ static inline sys_snode_t *sys_slist_get(sys_slist_t *list) { return sys_slist_is_empty(list) ? NULL : sys_slist_get_not_empty(list); } /** * @brief Remove a node * * This and other sys_slist_*() functions are not thread safe. * * @param list A pointer on the list to affect * @param prev_node A pointer on the previous node * (can be NULL, which means the node is the list's head) * @param node A pointer on the node to remove */ static inline void sys_slist_remove(sys_slist_t *list, sys_snode_t *prev_node, sys_snode_t *node) { if (!prev_node) { list->head = node->next; /* Was node also the tail? */ if (list->tail == node) { list->tail = list->head; } } else { prev_node->next = node->next; /* Was node the tail? */ if (list->tail == node) { list->tail = prev_node; } } node->next = NULL; } /** * @brief Find and remove a node from a list * * This and other sys_slist_*() functions are not thread safe. * * @param list A pointer on the list to affect * @param node A pointer on the node to remove from the list * * @return true if node was removed */ static inline bool sys_slist_find_and_remove(sys_slist_t *list, sys_snode_t *node) { sys_snode_t *prev = NULL; sys_snode_t *test; SYS_SLIST_FOR_EACH_NODE(list, test) { if (test == node) { sys_slist_remove(list, prev, node); return true; } prev = test; } return false; } #ifdef __cplusplus } #endif #endif /* __SLIST_H__ */ |