blob: c09ed513cd94539a66d209aebc379d67a628e04c [file] [log] [blame]
/*
******************************************************************************
* Copyright (C) 1999-2010, International Business Machines Corporation and *
* others. All Rights Reserved. *
******************************************************************************
*/
#include "uvectr64.h"
#include "cmemory.h"
#include "putilimp.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
*/
UOBJECT_DEFINE_RTTI_IMPLEMENTATION(UVector64)
UVector64::UVector64(UErrorCode &status) :
count(0),
capacity(0),
maxCapacity(0),
elements(NULL)
{
_init(DEFAULT_CAPACITY, status);
}
UVector64::UVector64(int32_t initialCapacity, UErrorCode &status) :
count(0),
capacity(0),
maxCapacity(0),
elements(0)
{
_init(initialCapacity, status);
}
void UVector64::_init(int32_t initialCapacity, UErrorCode &status) {
// Fix bogus initialCapacity values; avoid malloc(0)
if (initialCapacity < 1) {
initialCapacity = DEFAULT_CAPACITY;
}
if (maxCapacity>0 && maxCapacity<initialCapacity) {
initialCapacity = maxCapacity;
}
if (initialCapacity > (int32_t)(INT32_MAX / sizeof(int64_t))) {
initialCapacity = uprv_min(DEFAULT_CAPACITY, maxCapacity);
}
elements = (int64_t *)uprv_malloc(sizeof(int64_t)*initialCapacity);
if (elements == 0) {
status = U_MEMORY_ALLOCATION_ERROR;
} else {
capacity = initialCapacity;
}
}
UVector64::~UVector64() {
uprv_free(elements);
elements = 0;
}
/**
* Assign this object to another (make this a copy of 'other').
*/
void UVector64::assign(const UVector64& other, UErrorCode &ec) {
if (ensureCapacity(other.count, ec)) {
setSize(other.count);
for (int32_t i=0; i<other.count; ++i) {
elements[i] = other.elements[i];
}
}
}
UBool UVector64::operator==(const UVector64& other) {
int32_t i;
if (count != other.count) return FALSE;
for (i=0; i<count; ++i) {
if (elements[i] != other.elements[i]) {
return FALSE;
}
}
return TRUE;
}
void UVector64::setElementAt(int64_t elem, int32_t index) {
if (0 <= index && index < count) {
elements[index] = elem;
}
/* else index out of range */
}
void UVector64::insertElementAt(int64_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] = elem;
++count;
}
/* else index out of range */
}
void UVector64::removeAllElements(void) {
count = 0;
}
UBool UVector64::expandCapacity(int32_t minimumCapacity, UErrorCode &status) {
if (minimumCapacity < 0) {
status = U_ILLEGAL_ARGUMENT_ERROR;
return FALSE;
}
if (capacity >= minimumCapacity) {
return TRUE;
}
if (maxCapacity>0 && minimumCapacity>maxCapacity) {
status = U_BUFFER_OVERFLOW_ERROR;
return FALSE;
}
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 (maxCapacity > 0 && newCap > maxCapacity) {
newCap = maxCapacity;
}
if (newCap > (int32_t)(INT32_MAX / sizeof(int64_t))) { // integer overflow check
// We keep the original memory contents on bad minimumCapacity/maxCapacity.
status = U_ILLEGAL_ARGUMENT_ERROR;
return FALSE;
}
int64_t* newElems = (int64_t *)uprv_realloc(elements, sizeof(int64_t)*newCap);
if (newElems == NULL) {
// We keep the original contents on the memory failure on realloc.
status = U_MEMORY_ALLOCATION_ERROR;
return FALSE;
}
elements = newElems;
capacity = newCap;
return TRUE;
}
void UVector64::setMaxCapacity(int32_t limit) {
U_ASSERT(limit >= 0);
if (limit < 0) {
limit = 0;
}
if (limit > (int32_t)(INT32_MAX / sizeof(int64_t))) { // integer overflow check for realloc
// Something is very wrong, don't realloc, leave capacity and maxCapacity unchanged
return;
}
maxCapacity = limit;
if (capacity <= maxCapacity || maxCapacity == 0) {
// Current capacity is within the new limit.
return;
}
// New maximum capacity is smaller than the current size.
// Realloc the storage to the new, smaller size.
int64_t* newElems = (int64_t *)uprv_realloc(elements, sizeof(int64_t)*maxCapacity);
if (newElems == NULL) {
// Realloc to smaller failed.
// Just keep what we had. No need to call it a failure.
return;
}
elements = newElems;
capacity = maxCapacity;
if (count > capacity) {
count = capacity;
}
}
/**
* 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 UVector64::setSize(int32_t newSize) {
int32_t i;
if (newSize < 0) {
return;
}
if (newSize > count) {
UErrorCode ec = U_ZERO_ERROR;
if (!ensureCapacity(newSize, ec)) {
return;
}
for (i=count; i<newSize; ++i) {
elements[i] = 0;
}
}
count = newSize;
}
U_NAMESPACE_END