LinkedList.c

 
#include <winpr/config.h>
 
#include <winpr/collections.h>
#include <winpr/assert.h>
 
typedef struct s_wLinkedListItem wLinkedListNode;
 
struct s_wLinkedListItem
{
  void* value;
  wLinkedListNode* prev;
  wLinkedListNode* next;
};
 
struct s_wLinkedList
{
  size_t count;
  int initial;
  wLinkedListNode* head;
  wLinkedListNode* tail;
  wLinkedListNode* current;
  wObject object;
};
 
size_t LinkedList_Count(wLinkedList* list)
{
  WINPR_ASSERT(list);
  return list->count;
}
 
void* LinkedList_First(wLinkedList* list)
{
  WINPR_ASSERT(list);
  if (list->head)
    return list->head->value;
  else
    return nullptr;
}
 
void* LinkedList_Last(wLinkedList* list)
{
  WINPR_ASSERT(list);
  if (list->tail)
    return list->tail->value;
  else
    return nullptr;
}
 
BOOL LinkedList_Contains(wLinkedList* list, const void* value)
{
  wLinkedListNode* item = nullptr;
  OBJECT_EQUALS_FN keyEquals = nullptr;
 
  WINPR_ASSERT(list);
  if (!list->head)
    return FALSE;
 
  item = list->head;
  keyEquals = list->object.fnObjectEquals;
 
  while (item)
  {
    if (keyEquals(item->value, value))
      break;
 
    item = item->next;
  }
 
  return (item != nullptr);
}
 
static wLinkedListNode* LinkedList_FreeNode(wLinkedList* list, wLinkedListNode* node)
{
  wLinkedListNode* next = nullptr;
  wLinkedListNode* prev = nullptr;
 
  WINPR_ASSERT(list);
  WINPR_ASSERT(node);
 
  next = node->next;
  prev = node->prev;
  if (prev)
    prev->next = next;
 
  if (next)
    next->prev = prev;
 
  if (node == list->head)
    list->head = node->next;
 
  if (node == list->tail)
    list->tail = node->prev;
 
  if (node == list->current)
  {
    /* Never leave the enumerator on a freed node: the next MoveNext continues after the removed
     * node. */
    list->current = prev;
    if (!prev)
      list->initial = 1;
  }
 
  if (list->object.fnObjectUninit)
    list->object.fnObjectUninit(node);
 
  if (list->object.fnObjectFree)
    list->object.fnObjectFree(node);
 
  free(node);
  list->count--;
  return next;
}
 
void LinkedList_Clear(wLinkedList* list)
{
  wLinkedListNode* node = nullptr;
  WINPR_ASSERT(list);
  if (!list->head)
    return;
 
  node = list->head;
 
  while (node)
    node = LinkedList_FreeNode(list, node);
 
  list->head = list->tail = nullptr;
  list->count = 0;
}
 
static wLinkedListNode* LinkedList_Create(wLinkedList* list, const void* value)
{
  wLinkedListNode* node = nullptr;
 
  WINPR_ASSERT(list);
  node = (wLinkedListNode*)calloc(1, sizeof(wLinkedListNode));
 
  if (!node)
    return nullptr;
 
  if (list->object.fnObjectNew)
    node->value = list->object.fnObjectNew(value);
  else
  {
    union
    {
      const void* cpv;
      void* pv;
    } cnv;
    cnv.cpv = value;
    node->value = cnv.pv;
  }
 
  if (list->object.fnObjectInit)
    list->object.fnObjectInit(node);
 
  return node;
}
BOOL LinkedList_AddFirst(wLinkedList* list, const void* value)
{
  wLinkedListNode* node = LinkedList_Create(list, value);
 
  if (!node)
    return FALSE;
 
  if (!list->head)
  {
    list->tail = list->head = node;
  }
  else
  {
    list->head->prev = node;
    node->next = list->head;
    list->head = node;
  }
 
  list->count++;
  return TRUE;
}
 
BOOL LinkedList_AddLast(wLinkedList* list, const void* value)
{
  wLinkedListNode* node = LinkedList_Create(list, value);
 
  if (!node)
    return FALSE;
 
  if (!list->tail)
  {
    list->head = list->tail = node;
  }
  else
  {
    list->tail->next = node;
    node->prev = list->tail;
    list->tail = node;
  }
 
  list->count++;
  return TRUE;
}
 
BOOL LinkedList_Remove(wLinkedList* list, const void* value)
{
  wLinkedListNode* node = nullptr;
  OBJECT_EQUALS_FN keyEquals = nullptr;
  WINPR_ASSERT(list);
 
  keyEquals = list->object.fnObjectEquals;
  node = list->head;
 
  while (node)
  {
    if (keyEquals(node->value, value))
    {
      LinkedList_FreeNode(list, node);
      return TRUE;
    }
 
    node = node->next;
  }
 
  return FALSE;
}
 
void LinkedList_RemoveFirst(wLinkedList* list)
{
  WINPR_ASSERT(list);
  if (list->head)
    LinkedList_FreeNode(list, list->head);
}
 
void LinkedList_RemoveLast(wLinkedList* list)
{
  WINPR_ASSERT(list);
  if (list->tail)
    LinkedList_FreeNode(list, list->tail);
}
 
void LinkedList_Enumerator_Reset(wLinkedList* list)
{
  WINPR_ASSERT(list);
  list->initial = 1;
  list->current = nullptr;
}
 
/*
 * Gets the element at the current position of the enumerator.
 */
 
void* LinkedList_Enumerator_Current(wLinkedList* list)
{
  WINPR_ASSERT(list);
  if (list->initial)
    return nullptr;
 
  if (list->current)
    return list->current->value;
  else
    return nullptr;
}
 
/*
 * Advances the enumerator to the next element of the LinkedList.
 */
 
BOOL LinkedList_Enumerator_MoveNext(wLinkedList* list)
{
  WINPR_ASSERT(list);
  if (list->initial)
  {
    list->initial = 0;
    list->current = list->head;
  }
  else if (list->current)
    list->current = list->current->next;
 
  if (!list->current)
    return FALSE;
 
  return TRUE;
}
 
static BOOL default_equal_function(const void* objA, const void* objB)
{
  return objA == objB;
}
 
wLinkedList* LinkedList_New(void)
{
  wLinkedList* list = nullptr;
  list = (wLinkedList*)calloc(1, sizeof(wLinkedList));
 
  if (list)
  {
    list->object.fnObjectEquals = default_equal_function;
  }
 
  return list;
}
 
void LinkedList_Free(wLinkedList* list)
{
  if (list)
  {
    LinkedList_Clear(list);
    free(list);
  }
}
 
wObject* LinkedList_Object(wLinkedList* list)
{
  WINPR_ASSERT(list);
 
  return &list->object;
}