tor-browser

ulist.cpp (7121B)

---

// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
******************************************************************************
*   Copyright (C) 2009-2016, International Business Machines
*   Corporation and others.  All Rights Reserved.
******************************************************************************
*/

#include "ulist.h"
#include "cmemory.h"
#include "cstring.h"
#include "uenumimp.h"

typedef struct UListNode UListNode;
struct UListNode {
   void *data;
   
   UListNode *next;
   UListNode *previous;
   
   /* When data is created with uprv_malloc, needs to be freed during deleteList function. */
   UBool forceDelete;
};

struct UList {
   UListNode *curr;
   UListNode *head;
   UListNode *tail;
   
   int32_t size;
};

static void ulist_addFirstItem(UList *list, UListNode *newItem);

U_CAPI UList *U_EXPORT2 ulist_createEmptyList(UErrorCode *status) {
   UList *newList = nullptr;
   
   if (U_FAILURE(*status)) {
       return nullptr;
   }
   
   newList = (UList *)uprv_malloc(sizeof(UList));
   if (newList == nullptr) {
       *status = U_MEMORY_ALLOCATION_ERROR;
       return nullptr;
   }
   
   newList->curr = nullptr;
   newList->head = nullptr;
   newList->tail = nullptr;
   newList->size = 0;
   
   return newList;
}

/*
* Function called by addItemEndList or addItemBeginList when the first item is added to the list.
* This function properly sets the pointers for the first item added.
*/
static void ulist_addFirstItem(UList *list, UListNode *newItem) {
   newItem->next = nullptr;
   newItem->previous = nullptr;
   list->head = newItem;
   list->tail = newItem;
}

static void ulist_removeItem(UList *list, UListNode *p) {
   if (p->previous == nullptr) {
       // p is the list head.
       list->head = p->next;
   } else {
       p->previous->next = p->next;
   }
   if (p->next == nullptr) {
       // p is the list tail.
       list->tail = p->previous;
   } else {
       p->next->previous = p->previous;
   }
   if (p == list->curr) {
       list->curr = p->next;
   }
   --list->size;
   if (p->forceDelete) {
       uprv_free(p->data);
   }
   uprv_free(p);
}

U_CAPI void U_EXPORT2 ulist_addItemEndList(UList *list, const void *data, UBool forceDelete, UErrorCode *status) {
   UListNode *newItem = nullptr;
   
   if (U_FAILURE(*status) || list == nullptr || data == nullptr) {
       if (forceDelete) {
           uprv_free((void *)data);
       }
       return;
   }
   
   newItem = (UListNode *)uprv_malloc(sizeof(UListNode));
   if (newItem == nullptr) {
       if (forceDelete) {
           uprv_free((void *)data);
       }
       *status = U_MEMORY_ALLOCATION_ERROR;
       return;
   }
   newItem->data = (void *)(data);
   newItem->forceDelete = forceDelete;
   
   if (list->size == 0) {
       ulist_addFirstItem(list, newItem);
   } else {
       newItem->next = nullptr;
       newItem->previous = list->tail;
       list->tail->next = newItem;
       list->tail = newItem;
   }
   
   list->size++;
}

U_CAPI void U_EXPORT2 ulist_addItemBeginList(UList *list, const void *data, UBool forceDelete, UErrorCode *status) {
   UListNode *newItem = nullptr;
   
   if (U_FAILURE(*status) || list == nullptr || data == nullptr) {
       if (forceDelete) {
           uprv_free((void *)data);
       }
       return;
   }
   
   newItem = (UListNode *)uprv_malloc(sizeof(UListNode));
   if (newItem == nullptr) {
       if (forceDelete) {
           uprv_free((void *)data);
       }
       *status = U_MEMORY_ALLOCATION_ERROR;
       return;
   }
   newItem->data = (void *)(data);
   newItem->forceDelete = forceDelete;
   
   if (list->size == 0) {
       ulist_addFirstItem(list, newItem);
   } else {
       newItem->previous = nullptr;
       newItem->next = list->head;
       list->head->previous = newItem;
       list->head = newItem;
   }
   
   list->size++;
}

U_CAPI UBool U_EXPORT2 ulist_containsString(const UList *list, const char *data, int32_t length) {
   if (list != nullptr) {
       const UListNode *pointer;
       for (pointer = list->head; pointer != nullptr; pointer = pointer->next) {
           if (length == (int32_t)uprv_strlen((const char *)pointer->data)) {
               if (uprv_memcmp(data, pointer->data, length) == 0) {
                   return true;
               }
           }
       }
   }
   return false;
}

U_CAPI UBool U_EXPORT2 ulist_removeString(UList *list, const char *data) {
   if (list != nullptr) {
       UListNode *pointer;
       for (pointer = list->head; pointer != nullptr; pointer = pointer->next) {
           if (uprv_strcmp(data, (const char *)pointer->data) == 0) {
               ulist_removeItem(list, pointer);
               // Remove only the first occurrence, like Java LinkedList.remove(Object).
               return true;
           }
       }
   }
   return false;
}

U_CAPI void *U_EXPORT2 ulist_getNext(UList *list) {
   UListNode *curr = nullptr;
   
   if (list == nullptr || list->curr == nullptr) {
       return nullptr;
   }
   
   curr = list->curr;
   list->curr = curr->next;
   
   return curr->data;
}

U_CAPI int32_t U_EXPORT2 ulist_getListSize(const UList *list) {
   if (list != nullptr) {
       return list->size;
   }
   
   return -1;
}

U_CAPI void U_EXPORT2 ulist_resetList(UList *list) {
   if (list != nullptr) {
       list->curr = list->head;
   }
}

U_CAPI void U_EXPORT2 ulist_deleteList(UList *list) {
   UListNode *listHead = nullptr;

   if (list != nullptr) {
       listHead = list->head;
       while (listHead != nullptr) {
           UListNode *listPointer = listHead->next;

           if (listHead->forceDelete) {
               uprv_free(listHead->data);
           }

           uprv_free(listHead);
           listHead = listPointer;
       }
       uprv_free(list);
       list = nullptr;
   }
}

U_CAPI void U_EXPORT2 ulist_close_keyword_values_iterator(UEnumeration *en) {
   if (en != nullptr) {
       ulist_deleteList((UList *)(en->context));
       uprv_free(en);
   }
}

U_CAPI int32_t U_EXPORT2 ulist_count_keyword_values(UEnumeration *en, UErrorCode *status) {
   if (U_FAILURE(*status)) {
       return -1;
   }
   
   return ulist_getListSize((UList *)(en->context));
}

U_CAPI const char * U_EXPORT2 ulist_next_keyword_value(UEnumeration *en, int32_t *resultLength, UErrorCode *status) {
   const char *s;
   if (U_FAILURE(*status)) {
       return nullptr;
   }

   s = (const char *)ulist_getNext((UList *)(en->context));
   if (s != nullptr && resultLength != nullptr) {
       *resultLength = static_cast<int32_t>(uprv_strlen(s));
   }
   return s;
}

U_CAPI void U_EXPORT2 ulist_reset_keyword_values_iterator(UEnumeration *en, UErrorCode *status) {
   if (U_FAILURE(*status)) {
       return ;
   }
   
   ulist_resetList((UList *)(en->context));
}

U_CAPI UList * U_EXPORT2 ulist_getListFromEnum(UEnumeration *en) {
   return (UList *)(en->context);
}