Line data    Source code

       1             : /**
       2             :  * Copyright (c) 2025 Huawei Technologies Co., Ltd.
       3             :  * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
       4             :  * CANN Open Software License Agreement Version 2.0 (the "License").
       5             :  * Please refer to the License for details. You may not use this file except in compliance with the License.
       6             :  * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
       7             :  * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
       8             :  * See LICENSE in the root of the software repository for the full text of the License.
       9             :  */
      10             : #ifndef C_BASE_SINGLE_LIST_H
      11             : #define C_BASE_SINGLE_LIST_H
      12             : #include "c_base.h"
      13             : #ifdef __cplusplus
      14             : extern "C" {
      15             : #endif
      16             : typedef struct CSingleListNode {
      17             :     struct CSingleListNode *next;
      18             : } CSingleListNode;
      19             : 
      20             : typedef struct {
      21             :     CSingleListNode *head;
      22             :     CSingleListNode *tail;
      23             : } CSingleList;
      24             : 
      25             : /**
      26             :  * You can use this macro to initialize the linked list while defining it,
      27             :  *  or use the function InitCSingleList to initialize it before use
      28             :  */
      29             : #define CSINGLE_LIST_INIT {NULL, NULL}
      30             : #define CSingleListNext(curNode) ((curNode) != NULL) ? (curNode)->next : NULL
      31             : 
      32             : /**
      33             :  * Through this macro, the traversal of the linked list can be realized.
      34             :  *  The user needs to define the loop variables curNode, nextNode,
      35             :  *  and the loop variable does not need to be initialized.
      36             :  */
      37             : #define CSingleListForEach(list, curNode, nextNode)                                          \
      38             :     for ((curNode) = (list)->head, (nextNode) = CSingleListNext(curNode); (curNode) != NULL; \
      39             :          (curNode) = (nextNode), (nextNode) = CSingleListNext(nextNode))
      40             : 
      41           0 : static inline void InitCSingleList(CSingleList *list)
      42             : {
      43           0 :     list->head = NULL;
      44           0 :     list->tail = NULL;
      45           0 : }
      46             : 
      47           0 : static inline bool IsSingleListEmpty(CSingleList *list)
      48             : {
      49           0 :     return list->head == NULL;
      50             : }
      51             : 
      52           0 : static inline CSingleListNode* GetSingleListHead(CSingleList *list)
      53             : {
      54           0 :     return list->head;
      55             : }
      56             : 
      57             : static inline void InsertCSingleListHead(CSingleList *list, CSingleListNode *insertNode)
      58             : {
      59             :     insertNode->next = list->head;
      60             :     list->head = insertNode;
      61             :     if (list->tail == NULL) {
      62             :         list->tail = insertNode;
      63             :     }
      64             : }
      65             : 
      66           0 : static inline void InsertCSingleListTail(CSingleList *list, CSingleListNode *insertNode)
      67             : {
      68           0 :     insertNode->next = NULL;
      69           0 :     if (list->tail == NULL) {
      70           0 :         list->head = insertNode;
      71             :     } else {
      72           0 :         list->tail->next = insertNode;
      73             :     }
      74           0 :     list->tail = insertNode;
      75           0 : }
      76             : 
      77             : static inline void InsertCSingleList(CSingleList *list, CSingleListNode *listNode, CSingleListNode *insertNode)
      78             : {
      79             :     insertNode->next = listNode->next;
      80             :     listNode->next = insertNode;
      81             :     if (list->tail == listNode) {
      82             :         list->tail = insertNode;
      83             :     }
      84             : }
      85             : 
      86           0 : static inline void RemoveCSingleListNode(CSingleList *list, CSingleListNode *listNode)
      87             : {
      88             :     CSingleListNode *curNode;
      89             :     CSingleListNode *nextNode;
      90           0 :     CSingleListNode *preNode = NULL;
      91           0 :     CSingleListForEach(list, curNode, nextNode) {
      92           0 :         if (curNode != listNode) {
      93           0 :             preNode = curNode;
      94           0 :             continue;
      95             :         }
      96             : 
      97           0 :         if (preNode == NULL) {
      98           0 :             list->head = nextNode;
      99           0 :             if (list->head == NULL) {
     100           0 :                 list->tail = NULL;
     101             :             }
     102             :         } else {
     103           0 :             preNode->next = curNode->next;
     104           0 :             if (nextNode == NULL) {
     105           0 :                 list->tail = preNode;
     106             :             }
     107             :         }
     108             :     }
     109           0 : }
     110             : 
     111           0 : static inline void RemoveCSingleListHead(CSingleList *list)
     112             : {
     113           0 :     RemoveCSingleListNode(list, list->head);
     114           0 : }
     115             : 
     116             : static inline void RemoveCSingleListTail(CSingleList *list)
     117             : {
     118             :     RemoveCSingleListNode(list, list->tail);
     119             : }
     120             : #ifdef __cplusplus
     121             : }
     122             : #endif
     123             : #endif // C_BASE_SINGLE_LIST_H