mirror of
https://gitee.com/openharmony/startup_init
synced 2024-11-24 16:49:58 +00:00
3d0cb75004
Signed-off-by: laiguizhong <laiguizhong@huawei.com> Change-Id: I6c42c9188329e875f5f9fcdeeab096a4c5dea202
206 lines
6.5 KiB
C
Executable File
206 lines
6.5 KiB
C
Executable File
/*
|
|
* Copyright (c) 2021 Huawei Device Co., Ltd.
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#ifndef BASE_STARTUP_INITLITE_LIST_H
|
|
#define BASE_STARTUP_INITLITE_LIST_H
|
|
#include <stddef.h>
|
|
|
|
#ifdef __cplusplus
|
|
#if __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
#endif
|
|
|
|
/**
|
|
* @brief Double linked list structure is show as below:
|
|
*
|
|
* |￣￣￣￣￣|-----------------------------------------------|
|
|
* |->| head | |
|
|
* | |________|<-------------------------------------------| |
|
|
* | | | |
|
|
* | └-next->|▔▔▔▔▔▔|-next->|▔▔▔▔▔▔|-next->|▔▔▔▔▔▔|-next--| |
|
|
* └------prev-| node |<-prev-| node |<-prev-| node |<-prev----|
|
|
* |------| |------| |------|
|
|
* | extra| | extra| | extra|
|
|
* |______| |______| |______|
|
|
*
|
|
* Usage Example:
|
|
* 1. Define structure for each item in the list
|
|
* typedef struct tagTEST_LIST_ITEM {
|
|
* ListNode node;
|
|
* int value;
|
|
* } TEST_LIST_ITEM;
|
|
*
|
|
* 2. Define a list and init list by OH_ListAddTail
|
|
* ListNode testList;
|
|
* c(&testList);
|
|
*
|
|
* 3. Define a list item instance
|
|
* TEST_LIST_ITEM item;
|
|
* item.value = 0;
|
|
*
|
|
* 4. Add list item to list
|
|
* OH_ListAddTail(&testList, (ListNode *)(&item));
|
|
*
|
|
* 5. Advanced usage: add with order
|
|
* // Ordering compare function
|
|
* static int TestListItemCompareProc(ListNode *node, ListNode *newNode)
|
|
* {
|
|
* TEST_LIST_ITEM *left = (TEST_LIST_ITEM *)node;
|
|
* TEST_LIST_ITEM *right = (TEST_LIST_ITEM *)newNode;
|
|
* return left->value - right->value;
|
|
* }
|
|
* OH_ListAddWithOrder(&testList, (ListNode *)(&item))
|
|
*/
|
|
|
|
/**
|
|
* @brief Double linked list node
|
|
*/
|
|
typedef struct ListNode {
|
|
struct ListNode *next;
|
|
struct ListNode *prev;
|
|
} ListNode, ListHead;
|
|
|
|
#define ListEmpty(node) ((node).next == &(node) && (node).prev == &(node))
|
|
#define ListEntry(ptr, type, member) ((type *)((char *)(ptr) - offsetof(type, member)))
|
|
#define ForEachListEntry(list, node) for (node = (list)->next; node != (list); node = node->next)
|
|
|
|
/**
|
|
* @brief Initialize a double-linked list head
|
|
*
|
|
* All other list API should be initialized by this function.\n
|
|
*
|
|
* @param head list head, make sure head is valid pointer
|
|
* @return None
|
|
*/
|
|
void OH_ListInit(struct ListNode *list);
|
|
|
|
/**
|
|
* @brief Add a node to the end of the list
|
|
*
|
|
* @param head list head, make sure head is valid pointer
|
|
* @param item new node to be added
|
|
* @return None
|
|
*/
|
|
void OH_ListAddTail(struct ListNode *list, struct ListNode *item);
|
|
|
|
/**
|
|
* @brief Remove a node from the list
|
|
*
|
|
* @param item the node to be removed from the list.
|
|
* This function does not free any memory within item.
|
|
* @return None
|
|
*/
|
|
void OH_ListRemove(struct ListNode *item);
|
|
|
|
/**
|
|
* @brief ListNode comparison function prototype
|
|
*
|
|
* @param node ListNode to be compared.
|
|
* @param newNode new ListNode to be compared.
|
|
* @return
|
|
* <0 if node < newNode
|
|
* =0 if node = newNode
|
|
* >0 if Node > newNode
|
|
*/
|
|
typedef int (*ListCompareProc)(ListNode *node, ListNode *newNode);
|
|
|
|
/**
|
|
* @brief Add a node to the list with order
|
|
*
|
|
* @param head list head, make sure head is valid pointer
|
|
* @param item new node to be added
|
|
* @param compareProc comparison function for adding node
|
|
* if it is ascending order, this function should return an integer less than,
|
|
* equal to, or greater than zero if the first argument is considered to be
|
|
* respectively less than, equal to, or greater than the second.
|
|
* @return None
|
|
*/
|
|
void OH_ListAddWithOrder(struct ListNode *head, struct ListNode *item, ListCompareProc compareProc);
|
|
|
|
/**
|
|
* @brief ListNode traversing and find function prototype
|
|
*
|
|
* @param node ListNode to be compared.
|
|
* @param data value for traversing
|
|
* @return
|
|
* return 0 if node value equals data for OH_ListFind
|
|
*/
|
|
typedef int (*ListTraversalProc)(ListNode *node, void *data);
|
|
|
|
/**
|
|
* @brief Find a node by traversing the list
|
|
*
|
|
* @param head list head, make sure head is valid pointer.
|
|
* @param data comparing data.
|
|
* @param compareProc comparing function, return 0 if matched.
|
|
* @return the found node; return NULL if none is found.
|
|
*/
|
|
ListNode *OH_ListFind(const ListNode *head, void *data, ListTraversalProc compareProc);
|
|
|
|
/* Traversing from end to start */
|
|
#define TRAVERSE_REVERSE_ORDER 0x1
|
|
/* Stop traversing when error returned */
|
|
#define TRAVERSE_STOP_WHEN_ERROR 0x2
|
|
|
|
/**
|
|
* @brief Traversal the list with specified function
|
|
*
|
|
* @param head list head, make sure head is valid pointer.
|
|
* @param cookie optional traversing data.
|
|
* @param traversalProc comparing function, return 0 if matched.
|
|
* @param flags optional traversing flags:
|
|
* TRAVERSE_REVERSE_ORDER: traversing from last node to first node;
|
|
* default behaviour is from first node to last node
|
|
* TRAVERSE_STOP_WHEN_ERROR: stop traversing if traversalProc return non-zero
|
|
* default behaviour will ignore traversalProc return values
|
|
* @return return -1 for invalid input arguments.
|
|
* when TRAVERSE_STOP_WHEN_ERROR is specified, it will return errors from traversalProc
|
|
*/
|
|
int OH_ListTraversal(ListNode *head, void *data, ListTraversalProc traversalProc, int flags);
|
|
|
|
/**
|
|
* @brief ListNode destroy function prototype
|
|
*
|
|
* @param node ListNode to be destroyed.
|
|
* @return None
|
|
*/
|
|
typedef void (*ListDestroyProc)(ListNode *node);
|
|
|
|
/**
|
|
* @brief Find a node by traversing the list
|
|
*
|
|
* @param head list head, make sure head is valid pointer.
|
|
* @param destroyProc destroy function; if NULL, it will free each node by default.
|
|
* @return None
|
|
*/
|
|
void OH_ListRemoveAll(ListNode *head, ListDestroyProc destroyProc);
|
|
|
|
/**
|
|
* @brief Get list count
|
|
*
|
|
* @param head list head, make sure head is valid pointer.
|
|
* @return the count of nodes in the list; return 0 if error
|
|
*/
|
|
int OH_ListGetCnt(const ListNode *head);
|
|
|
|
#ifdef __cplusplus
|
|
#if __cplusplus
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
#endif // BASE_STARTUP_INITLITE_LIST_H
|