list_api.h

Go to the documentation of this file.

// -------------------------------------------------------------------------------------------
// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
// This file is part of the AWS CDI-SDK, licensed under the BSD 2-Clause "Simplified" License.
// License details at: https://github.com/aws/aws-cdi-sdk/blob/mainline/LICENSE
// -------------------------------------------------------------------------------------------
 
#ifndef CDI_LIST_API_H__
#define CDI_LIST_API_H__
 
#include "utilities_api.h"
 
#include <assert.h>
#include <stddef.h>
#include <stdbool.h>
 
#include "cdi_os_api.h"
 
//*********************************************************************************************************************
//***************************************** START OF DEFINITIONS AND TYPES ********************************************
//*********************************************************************************************************************
 
typedef struct CdiListEntry CdiListEntry;
struct CdiListEntry {
    CdiListEntry* next_ptr; 
    CdiListEntry* prev_ptr; 
};
 
typedef struct {
    CdiListEntry head_entry; 
    unsigned int count;       
} CdiList;
 
typedef struct {
    CdiListEntry* head_ptr; 
    CdiListEntry* next_ptr; 
} CdiListIterator;
 
//*********************************************************************************************************************
//*********************************************** START OF VARIABLES **************************************************
//*********************************************************************************************************************
 
//*********************************************************************************************************************
//******************************************* START OF STATIC FUNCTIONS ***********************************************
//*********************************************************************************************************************
 
//*********************************************************************************************************************
//******************************************* START OF PUBLIC FUNCTIONS ***********************************************
//*********************************************************************************************************************
 
void CdiListInit(CdiList* list_ptr);
 
static inline CdiListEntry* CdiListGetHead(CdiList* list_ptr)
{
    return &list_ptr->head_entry;
}
 
static inline bool CdiListIsEmpty(const CdiList* list_ptr)
{
    return (0 >= list_ptr->count);
}
 
static inline void CdiListAddAfter(CdiList* list_ptr, CdiListEntry* new_entry_ptr, CdiListEntry* prev_entry_ptr)
{
    CdiListEntry *next_entry_ptr = prev_entry_ptr->next_ptr;
    // Update the new entry first, then insert it into the list. This allows multi-threaded access to read the list.
    new_entry_ptr->next_ptr = next_entry_ptr;
    new_entry_ptr->prev_ptr = prev_entry_ptr;
 
    next_entry_ptr->prev_ptr = new_entry_ptr;
    prev_entry_ptr->next_ptr = new_entry_ptr;
    list_ptr->count++;
}
 
static inline void CdiListAddBefore(CdiList* list_ptr, CdiListEntry* new_entry_ptr, CdiListEntry* next_entry_ptr)
{
    CdiListEntry *prev_entry_ptr = next_entry_ptr->prev_ptr;
    // Update the new entry first, then insert it into the list. This allows multi-threaded access to read the list.
    new_entry_ptr->next_ptr = next_entry_ptr;
    new_entry_ptr->prev_ptr = prev_entry_ptr;
 
    next_entry_ptr->prev_ptr = new_entry_ptr;
    prev_entry_ptr->next_ptr = new_entry_ptr;
    list_ptr->count++;
}
 
static inline void CdiListAddHead(CdiList* list_ptr, CdiListEntry* new_entry_ptr)
{
    CdiListAddBefore(list_ptr, new_entry_ptr, list_ptr->head_entry.next_ptr);
}
 
static inline void CdiListAddTail(CdiList* list_ptr, CdiListEntry* new_entry_ptr)
{
    CdiListAddAfter(list_ptr, new_entry_ptr, list_ptr->head_entry.prev_ptr);
}
 
static inline CdiListEntry* CdiListPeek(const CdiList* list_ptr)
{
    if (CdiListIsEmpty(list_ptr)) {
        return NULL;
    }
 
    return list_ptr->head_entry.next_ptr;
}
 
static inline CdiListEntry* CdiListPeekTail(const CdiList* list_ptr)
{
    if (CdiListIsEmpty(list_ptr)) {
        return NULL;
    }
 
    return list_ptr->head_entry.prev_ptr;
}
 
static inline void CdiListRemove(CdiList* list_ptr, CdiListEntry* entry_ptr)
{
    // CdiListEntries should always point to other entries or point back to themselves.  If the next_ptr is NULL then
    // the CdiListEntry was never added to a list and so should not be removed from the list.
    if (NULL != entry_ptr->next_ptr) {
        entry_ptr->next_ptr->prev_ptr = entry_ptr->prev_ptr;
        entry_ptr->prev_ptr->next_ptr = entry_ptr->next_ptr;
        entry_ptr->next_ptr = entry_ptr;
        entry_ptr->prev_ptr = entry_ptr;
 
        assert(list_ptr->count);
        list_ptr->count--;
    }
}
 
static inline CdiListEntry* CdiListPop(CdiList* list_ptr)
{
    CdiListEntry* first_ptr;
 
    if (CdiListIsEmpty(list_ptr)) {
        return NULL;
    }
 
    first_ptr = list_ptr->head_entry.next_ptr;
    CdiListRemove(list_ptr, first_ptr);
 
    return first_ptr;
}
 
static inline int CdiListCount(const CdiList* list_ptr)
{
    return list_ptr->count;
}
 
static inline void CdiListIteratorInit(CdiList* list_ptr, CdiListIterator* ret_iterator_ptr)
{
    ret_iterator_ptr->head_ptr = CdiListGetHead(list_ptr);
    ret_iterator_ptr->next_ptr = CdiListPeek(list_ptr);
}
 
static inline CdiListEntry* CdiListIteratorGetNext(CdiListIterator* iterator_ptr)
{
    CdiListEntry* ret_entry_ptr = iterator_ptr->next_ptr;
 
    // Don't walk an empty list.
    if (ret_entry_ptr) {
        // If at head of the list, then no more entries, so use NULL.
        if (ret_entry_ptr->next_ptr == iterator_ptr->head_ptr) {
            iterator_ptr->next_ptr = NULL;
        } else {
            iterator_ptr->next_ptr = ret_entry_ptr->next_ptr;
        }
    }
 
    return ret_entry_ptr;
}
 
#endif // CDI_LIST_API_H__