summaryrefslogtreecommitdiff
path: root/deps/node/deps/icu-small/source/common/uvector.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'deps/node/deps/icu-small/source/common/uvector.cpp')
-rw-r--r--deps/node/deps/icu-small/source/common/uvector.cpp566
1 files changed, 0 insertions, 566 deletions
diff --git a/deps/node/deps/icu-small/source/common/uvector.cpp b/deps/node/deps/icu-small/source/common/uvector.cpp
deleted file mode 100644
index ad3a813e..00000000
--- a/deps/node/deps/icu-small/source/common/uvector.cpp
+++ /dev/null
@@ -1,566 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
-******************************************************************************
-* Copyright (C) 1999-2013, International Business Machines Corporation and
-* others. All Rights Reserved.
-******************************************************************************
-* Date Name Description
-* 10/22/99 alan Creation.
-**********************************************************************
-*/
-
-#include "uvector.h"
-#include "cmemory.h"
-#include "uarrsort.h"
-#include "uelement.h"
-
-U_NAMESPACE_BEGIN
-
-#define DEFAULT_CAPACITY 8
-
-/*
- * Constants for hinting whether a key is an integer
- * or a pointer. If a hint bit is zero, then the associated
- * token is assumed to be an integer. This is needed for iSeries
- */
-#define HINT_KEY_POINTER (1)
-#define HINT_KEY_INTEGER (0)
-
-UOBJECT_DEFINE_RTTI_IMPLEMENTATION(UVector)
-
-UVector::UVector(UErrorCode &status) :
- count(0),
- capacity(0),
- elements(0),
- deleter(0),
- comparer(0)
-{
- _init(DEFAULT_CAPACITY, status);
-}
-
-UVector::UVector(int32_t initialCapacity, UErrorCode &status) :
- count(0),
- capacity(0),
- elements(0),
- deleter(0),
- comparer(0)
-{
- _init(initialCapacity, status);
-}
-
-UVector::UVector(UObjectDeleter *d, UElementsAreEqual *c, UErrorCode &status) :
- count(0),
- capacity(0),
- elements(0),
- deleter(d),
- comparer(c)
-{
- _init(DEFAULT_CAPACITY, status);
-}
-
-UVector::UVector(UObjectDeleter *d, UElementsAreEqual *c, int32_t initialCapacity, UErrorCode &status) :
- count(0),
- capacity(0),
- elements(0),
- deleter(d),
- comparer(c)
-{
- _init(initialCapacity, status);
-}
-
-void UVector::_init(int32_t initialCapacity, UErrorCode &status) {
- if (U_FAILURE(status)) {
- return;
- }
- // Fix bogus initialCapacity values; avoid malloc(0) and integer overflow
- if ((initialCapacity < 1) || (initialCapacity > (int32_t)(INT32_MAX / sizeof(UElement)))) {
- initialCapacity = DEFAULT_CAPACITY;
- }
- elements = (UElement *)uprv_malloc(sizeof(UElement)*initialCapacity);
- if (elements == 0) {
- status = U_MEMORY_ALLOCATION_ERROR;
- } else {
- capacity = initialCapacity;
- }
-}
-
-UVector::~UVector() {
- removeAllElements();
- uprv_free(elements);
- elements = 0;
-}
-
-/**
- * Assign this object to another (make this a copy of 'other').
- * Use the 'assign' function to assign each element.
- */
-void UVector::assign(const UVector& other, UElementAssigner *assign, UErrorCode &ec) {
- if (ensureCapacity(other.count, ec)) {
- setSize(other.count, ec);
- if (U_SUCCESS(ec)) {
- for (int32_t i=0; i<other.count; ++i) {
- if (elements[i].pointer != 0 && deleter != 0) {
- (*deleter)(elements[i].pointer);
- }
- (*assign)(&elements[i], &other.elements[i]);
- }
- }
- }
-}
-
-// This only does something sensible if this object has a non-null comparer
-UBool UVector::operator==(const UVector& other) {
- int32_t i;
- if (count != other.count) return FALSE;
- if (comparer != NULL) {
- // Compare using this object's comparer
- for (i=0; i<count; ++i) {
- if (!(*comparer)(elements[i], other.elements[i])) {
- return FALSE;
- }
- }
- }
- return TRUE;
-}
-
-void UVector::addElement(void* obj, UErrorCode &status) {
- if (ensureCapacity(count + 1, status)) {
- elements[count++].pointer = obj;
- }
-}
-
-void UVector::addElement(int32_t elem, UErrorCode &status) {
- if (ensureCapacity(count + 1, status)) {
- elements[count].pointer = NULL; // Pointers may be bigger than ints.
- elements[count].integer = elem;
- count++;
- }
-}
-
-void UVector::setElementAt(void* obj, int32_t index) {
- if (0 <= index && index < count) {
- if (elements[index].pointer != 0 && deleter != 0) {
- (*deleter)(elements[index].pointer);
- }
- elements[index].pointer = obj;
- }
- /* else index out of range */
-}
-
-void UVector::setElementAt(int32_t elem, int32_t index) {
- if (0 <= index && index < count) {
- if (elements[index].pointer != 0 && deleter != 0) {
- // TODO: this should be an error. mixing up ints and pointers.
- (*deleter)(elements[index].pointer);
- }
- elements[index].pointer = NULL;
- elements[index].integer = elem;
- }
- /* else index out of range */
-}
-
-void UVector::insertElementAt(void* obj, int32_t index, UErrorCode &status) {
- // must have 0 <= index <= count
- if (0 <= index && index <= count && ensureCapacity(count + 1, status)) {
- for (int32_t i=count; i>index; --i) {
- elements[i] = elements[i-1];
- }
- elements[index].pointer = obj;
- ++count;
- }
- /* else index out of range */
-}
-
-void UVector::insertElementAt(int32_t elem, int32_t index, UErrorCode &status) {
- // must have 0 <= index <= count
- if (0 <= index && index <= count && ensureCapacity(count + 1, status)) {
- for (int32_t i=count; i>index; --i) {
- elements[i] = elements[i-1];
- }
- elements[index].pointer = NULL;
- elements[index].integer = elem;
- ++count;
- }
- /* else index out of range */
-}
-
-void* UVector::elementAt(int32_t index) const {
- return (0 <= index && index < count) ? elements[index].pointer : 0;
-}
-
-int32_t UVector::elementAti(int32_t index) const {
- return (0 <= index && index < count) ? elements[index].integer : 0;
-}
-
-UBool UVector::containsAll(const UVector& other) const {
- for (int32_t i=0; i<other.size(); ++i) {
- if (indexOf(other.elements[i]) < 0) {
- return FALSE;
- }
- }
- return TRUE;
-}
-
-UBool UVector::containsNone(const UVector& other) const {
- for (int32_t i=0; i<other.size(); ++i) {
- if (indexOf(other.elements[i]) >= 0) {
- return FALSE;
- }
- }
- return TRUE;
-}
-
-UBool UVector::removeAll(const UVector& other) {
- UBool changed = FALSE;
- for (int32_t i=0; i<other.size(); ++i) {
- int32_t j = indexOf(other.elements[i]);
- if (j >= 0) {
- removeElementAt(j);
- changed = TRUE;
- }
- }
- return changed;
-}
-
-UBool UVector::retainAll(const UVector& other) {
- UBool changed = FALSE;
- for (int32_t j=size()-1; j>=0; --j) {
- int32_t i = other.indexOf(elements[j]);
- if (i < 0) {
- removeElementAt(j);
- changed = TRUE;
- }
- }
- return changed;
-}
-
-void UVector::removeElementAt(int32_t index) {
- void* e = orphanElementAt(index);
- if (e != 0 && deleter != 0) {
- (*deleter)(e);
- }
-}
-
-UBool UVector::removeElement(void* obj) {
- int32_t i = indexOf(obj);
- if (i >= 0) {
- removeElementAt(i);
- return TRUE;
- }
- return FALSE;
-}
-
-void UVector::removeAllElements(void) {
- if (deleter != 0) {
- for (int32_t i=0; i<count; ++i) {
- if (elements[i].pointer != 0) {
- (*deleter)(elements[i].pointer);
- }
- }
- }
- count = 0;
-}
-
-UBool UVector::equals(const UVector &other) const {
- int i;
-
- if (this->count != other.count) {
- return FALSE;
- }
- if (comparer == 0) {
- for (i=0; i<count; i++) {
- if (elements[i].pointer != other.elements[i].pointer) {
- return FALSE;
- }
- }
- } else {
- UElement key;
- for (i=0; i<count; i++) {
- key.pointer = &other.elements[i];
- if (!(*comparer)(key, elements[i])) {
- return FALSE;
- }
- }
- }
- return TRUE;
-}
-
-
-
-int32_t UVector::indexOf(void* obj, int32_t startIndex) const {
- UElement key;
- key.pointer = obj;
- return indexOf(key, startIndex, HINT_KEY_POINTER);
-}
-
-int32_t UVector::indexOf(int32_t obj, int32_t startIndex) const {
- UElement key;
- key.integer = obj;
- return indexOf(key, startIndex, HINT_KEY_INTEGER);
-}
-
-// This only works if this object has a non-null comparer
-int32_t UVector::indexOf(UElement key, int32_t startIndex, int8_t hint) const {
- int32_t i;
- if (comparer != 0) {
- for (i=startIndex; i<count; ++i) {
- if ((*comparer)(key, elements[i])) {
- return i;
- }
- }
- } else {
- for (i=startIndex; i<count; ++i) {
- /* Pointers are not always the same size as ints so to perform
- * a valid comparision we need to know whether we are being
- * provided an int or a pointer. */
- if (hint & HINT_KEY_POINTER) {
- if (key.pointer == elements[i].pointer) {
- return i;
- }
- } else {
- if (key.integer == elements[i].integer) {
- return i;
- }
- }
- }
- }
- return -1;
-}
-
-UBool UVector::ensureCapacity(int32_t minimumCapacity, UErrorCode &status) {
- if (minimumCapacity < 0) {
- status = U_ILLEGAL_ARGUMENT_ERROR;
- return FALSE;
- }
- if (capacity < minimumCapacity) {
- if (capacity > (INT32_MAX - 1) / 2) { // integer overflow check
- status = U_ILLEGAL_ARGUMENT_ERROR;
- return FALSE;
- }
- int32_t newCap = capacity * 2;
- if (newCap < minimumCapacity) {
- newCap = minimumCapacity;
- }
- if (newCap > (int32_t)(INT32_MAX / sizeof(UElement))) { // integer overflow check
- // We keep the original memory contents on bad minimumCapacity.
- status = U_ILLEGAL_ARGUMENT_ERROR;
- return FALSE;
- }
- UElement* newElems = (UElement *)uprv_realloc(elements, sizeof(UElement)*newCap);
- if (newElems == NULL) {
- // We keep the original contents on the memory failure on realloc or bad minimumCapacity.
- status = U_MEMORY_ALLOCATION_ERROR;
- return FALSE;
- }
- elements = newElems;
- capacity = newCap;
- }
- return TRUE;
-}
-
-/**
- * Change the size of this vector as follows: If newSize is smaller,
- * then truncate the array, possibly deleting held elements for i >=
- * newSize. If newSize is larger, grow the array, filling in new
- * slots with NULL.
- */
-void UVector::setSize(int32_t newSize, UErrorCode &status) {
- int32_t i;
- if (newSize < 0) {
- return;
- }
- if (newSize > count) {
- if (!ensureCapacity(newSize, status)) {
- return;
- }
- UElement empty;
- empty.pointer = NULL;
- empty.integer = 0;
- for (i=count; i<newSize; ++i) {
- elements[i] = empty;
- }
- } else {
- /* Most efficient to count down */
- for (i=count-1; i>=newSize; --i) {
- removeElementAt(i);
- }
- }
- count = newSize;
-}
-
-/**
- * Fill in the given array with all elements of this vector.
- */
-void** UVector::toArray(void** result) const {
- void** a = result;
- for (int i=0; i<count; ++i) {
- *a++ = elements[i].pointer;
- }
- return result;
-}
-
-UObjectDeleter *UVector::setDeleter(UObjectDeleter *d) {
- UObjectDeleter *old = deleter;
- deleter = d;
- return old;
-}
-
-UElementsAreEqual *UVector::setComparer(UElementsAreEqual *d) {
- UElementsAreEqual *old = comparer;
- comparer = d;
- return old;
-}
-
-/**
- * Removes the element at the given index from this vector and
- * transfer ownership of it to the caller. After this call, the
- * caller owns the result and must delete it and the vector entry
- * at 'index' is removed, shifting all subsequent entries back by
- * one index and shortening the size of the vector by one. If the
- * index is out of range or if there is no item at the given index
- * then 0 is returned and the vector is unchanged.
- */
-void* UVector::orphanElementAt(int32_t index) {
- void* e = 0;
- if (0 <= index && index < count) {
- e = elements[index].pointer;
- for (int32_t i=index; i<count-1; ++i) {
- elements[i] = elements[i+1];
- }
- --count;
- }
- /* else index out of range */
- return e;
-}
-
-/**
- * Insert the given object into this vector at its sorted position
- * as defined by 'compare'. The current elements are assumed to
- * be sorted already.
- */
-void UVector::sortedInsert(void* obj, UElementComparator *compare, UErrorCode& ec) {
- UElement e;
- e.pointer = obj;
- sortedInsert(e, compare, ec);
-}
-
-/**
- * Insert the given integer into this vector at its sorted position
- * as defined by 'compare'. The current elements are assumed to
- * be sorted already.
- */
-void UVector::sortedInsert(int32_t obj, UElementComparator *compare, UErrorCode& ec) {
- UElement e;
- e.integer = obj;
- sortedInsert(e, compare, ec);
-}
-
-// ASSUME elements[] IS CURRENTLY SORTED
-void UVector::sortedInsert(UElement e, UElementComparator *compare, UErrorCode& ec) {
- // Perform a binary search for the location to insert tok at. Tok
- // will be inserted between two elements a and b such that a <=
- // tok && tok < b, where there is a 'virtual' elements[-1] always
- // less than tok and a 'virtual' elements[count] always greater
- // than tok.
- int32_t min = 0, max = count;
- while (min != max) {
- int32_t probe = (min + max) / 2;
- int8_t c = (*compare)(elements[probe], e);
- if (c > 0) {
- max = probe;
- } else {
- // assert(c <= 0);
- min = probe + 1;
- }
- }
- if (ensureCapacity(count + 1, ec)) {
- for (int32_t i=count; i>min; --i) {
- elements[i] = elements[i-1];
- }
- elements[min] = e;
- ++count;
- }
-}
-
-/**
- * Array sort comparator function.
- * Used from UVector::sort()
- * Conforms to function signature required for uprv_sortArray().
- * This function is essentially just a wrapper, to make a
- * UVector style comparator function usable with uprv_sortArray().
- *
- * The context pointer to this function is a pointer back
- * (with some extra indirection) to the user supplied comparator.
- *
- */
-static int32_t U_CALLCONV
-sortComparator(const void *context, const void *left, const void *right) {
- UElementComparator *compare = *static_cast<UElementComparator * const *>(context);
- UElement e1 = *static_cast<const UElement *>(left);
- UElement e2 = *static_cast<const UElement *>(right);
- int32_t result = (*compare)(e1, e2);
- return result;
-}
-
-
-/**
- * Array sort comparison function for use from UVector::sorti()
- * Compares int32_t vector elements.
- */
-static int32_t U_CALLCONV
-sortiComparator(const void * /*context */, const void *left, const void *right) {
- const UElement *e1 = static_cast<const UElement *>(left);
- const UElement *e2 = static_cast<const UElement *>(right);
- int32_t result = e1->integer < e2->integer? -1 :
- e1->integer == e2->integer? 0 : 1;
- return result;
-}
-
-/**
- * Sort the vector, assuming it constains ints.
- * (A more general sort would take a comparison function, but it's
- * not clear whether UVector's UElementComparator or
- * UComparator from uprv_sortAray would be more appropriate.)
- */
-void UVector::sorti(UErrorCode &ec) {
- if (U_SUCCESS(ec)) {
- uprv_sortArray(elements, count, sizeof(UElement),
- sortiComparator, NULL, FALSE, &ec);
- }
-}
-
-
-/**
- * Sort with a user supplied comparator.
- *
- * The comparator function handling is confusing because the function type
- * for UVector (as defined for sortedInsert()) is different from the signature
- * required by uprv_sortArray(). This is handled by passing the
- * the UVector sort function pointer via the context pointer to a
- * sortArray() comparator function, which can then call back to
- * the original user functtion.
- *
- * An additional twist is that it's not safe to pass a pointer-to-function
- * as a (void *) data pointer, so instead we pass a (data) pointer to a
- * pointer-to-function variable.
- */
-void UVector::sort(UElementComparator *compare, UErrorCode &ec) {
- if (U_SUCCESS(ec)) {
- uprv_sortArray(elements, count, sizeof(UElement),
- sortComparator, &compare, FALSE, &ec);
- }
-}
-
-
-/**
- * Stable sort with a user supplied comparator of type UComparator.
- */
-void UVector::sortWithUComparator(UComparator *compare, const void *context, UErrorCode &ec) {
- if (U_SUCCESS(ec)) {
- uprv_sortArray(elements, count, sizeof(UElement),
- compare, context, TRUE, &ec);
- }
-}
-
-U_NAMESPACE_END
generated by cgit v1.2.3 (git 2.39.1) at 2024-04-23 20:34:44 +0000