520 lines
14 KiB
C++
520 lines
14 KiB
C++
/*
|
|
******************************************************************************
|
|
* Copyright (C) 1999-2004, International Business Machines Corporation and *
|
|
* others. All Rights Reserved. *
|
|
******************************************************************************
|
|
* Date Name Description
|
|
* 10/22/99 alan Creation.
|
|
**********************************************************************
|
|
*/
|
|
|
|
#include "uvector.h"
|
|
#include "cmemory.h"
|
|
|
|
U_NAMESPACE_BEGIN
|
|
|
|
#define DEFUALT_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(DEFUALT_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, UKeyComparator *c, UErrorCode &status) :
|
|
count(0),
|
|
capacity(0),
|
|
elements(0),
|
|
deleter(d),
|
|
comparer(c)
|
|
{
|
|
_init(DEFUALT_CAPACITY, status);
|
|
}
|
|
|
|
UVector::UVector(UObjectDeleter *d, UKeyComparator *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)
|
|
if (initialCapacity < 1) {
|
|
initialCapacity = DEFUALT_CAPACITY;
|
|
}
|
|
elements = (UHashTok *)uprv_malloc(sizeof(UHashTok)*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, UTokenAssigner *assign, UErrorCode &ec) {
|
|
if (ensureCapacity(other.count, ec)) {
|
|
setSize(other.count);
|
|
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 {
|
|
UHashTok 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 {
|
|
UHashTok key;
|
|
key.pointer = obj;
|
|
return indexOf(key, startIndex, HINT_KEY_POINTER);
|
|
}
|
|
|
|
int32_t UVector::indexOf(int32_t obj, int32_t startIndex) const {
|
|
UHashTok 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(UHashTok 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 (capacity >= minimumCapacity) {
|
|
return TRUE;
|
|
} else {
|
|
int32_t newCap = capacity * 2;
|
|
if (newCap < minimumCapacity) {
|
|
newCap = minimumCapacity;
|
|
}
|
|
UHashTok* newElems = (UHashTok *)uprv_malloc(sizeof(UHashTok)*newCap);
|
|
if (newElems == 0) {
|
|
status = U_MEMORY_ALLOCATION_ERROR;
|
|
return FALSE;
|
|
}
|
|
uprv_memcpy(newElems, elements, sizeof(elements[0]) * count);
|
|
uprv_free(elements);
|
|
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) {
|
|
int32_t i;
|
|
if (newSize < 0) {
|
|
return;
|
|
}
|
|
if (newSize > count) {
|
|
UErrorCode ec = U_ZERO_ERROR;
|
|
if (!ensureCapacity(newSize, ec)) {
|
|
return;
|
|
}
|
|
UHashTok 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;
|
|
}
|
|
|
|
UKeyComparator *UVector::setComparer(UKeyComparator *d) {
|
|
UKeyComparator *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, USortComparator *compare, UErrorCode& ec) {
|
|
UHashTok tok;
|
|
tok.pointer = obj;
|
|
sortedInsert(tok, 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, USortComparator *compare, UErrorCode& ec) {
|
|
UHashTok tok;
|
|
tok.integer = obj;
|
|
sortedInsert(tok, compare, ec);
|
|
}
|
|
|
|
// ASSUME elements[] IS CURRENTLY SORTED
|
|
void UVector::sortedInsert(UHashTok tok, USortComparator *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], tok);
|
|
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] = tok;
|
|
++count;
|
|
}
|
|
}
|
|
|
|
UStack::UStack(UErrorCode &status) :
|
|
UVector(status)
|
|
{
|
|
}
|
|
|
|
UStack::UStack(int32_t initialCapacity, UErrorCode &status) :
|
|
UVector(initialCapacity, status)
|
|
{
|
|
}
|
|
|
|
UStack::UStack(UObjectDeleter *d, UKeyComparator *c, UErrorCode &status) :
|
|
UVector(d, c, status)
|
|
{
|
|
}
|
|
|
|
UStack::UStack(UObjectDeleter *d, UKeyComparator *c, int32_t initialCapacity, UErrorCode &status) :
|
|
UVector(d, c, initialCapacity, status)
|
|
{
|
|
}
|
|
|
|
UStack::~UStack() {}
|
|
|
|
void* UStack::pop(void) {
|
|
int32_t n = size() - 1;
|
|
void* result = 0;
|
|
if (n >= 0) {
|
|
result = elementAt(n);
|
|
removeElementAt(n);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
int32_t UStack::popi(void) {
|
|
int32_t n = size() - 1;
|
|
int32_t result = 0;
|
|
if (n >= 0) {
|
|
result = elementAti(n);
|
|
removeElementAt(n);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
int32_t UStack::search(void* obj) const {
|
|
int32_t i = indexOf(obj);
|
|
return (i >= 0) ? size() - i : i;
|
|
}
|
|
|
|
U_NAMESPACE_END
|
|
|