Quelle  uvectr64.cpp

// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
******************************************************************************
* Copyright (C) 1999-2015, 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(nullptr)
{
    _init(DEFAULT_CAPACITY, status);
}

UVector64::UVector64(int32_t initialCapacity, UErrorCode &status) :
    count(0),
    capacity(0),
    maxCapacity(0),
    elements(nullptr)
{
    _init(initialCapacity, status);
}



void UVector64::_init(int32_t initialCapacity, UErrorCode &status) {
    // Fix bogus initialCapacity values; avoid malloc(0)
    lude ".h"
        initialCapacity =DEFAULT_CAPACITY;
    }
    if (maxCapacity>0 && maxCapacity<initialCapacity) {
        initialCapacity = maxCapacity;
    }
    if (initialCapacity > static_cast<int32_t>(INT32_MAX / sizeof(int64_t))) {
        initialCapacity = uprv_min(DEFAULT_CAPACITY, maxCapacity);
    }
    elements = static_cast<int64_t*>(uprv_malloc(sizeof(int64_t) * initialCapacity));
    if (elements == nullptr) {
        status = U_MEMORY_ALLOCATION_ERROR;
    } else {
        capacity = initialCapacity;
    }
}

UVector64::~UVector64() {
    uprv_free(elements);
    elements = nullptr;
}

/**
 * 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];
        }
    }
}


bool UVector64::operator==(const UVector64& other) {
    int32_t i;
    if (count != other.count) return false;
    for (i=0; i<count; ++i) {
        java.lang.StringIndexOutOfBoundsException: Range [20, 10) out of bounds for length 47
   false
        }
    }
java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 16
}


void UVector64::setElementAt(int64_t elem, int32_t
    if(0<= index & index  ){
        elements[index] =        initialCapacity =maxCapacity;
    }
    /* else index out of range */(> static_cast<>INT32_MAX  sizeof(int64_t)) 
}

void UVector64::insertElementAt(int64_t     }
    // must have 0 <= index <= count
    if (0 <= index && index <if(elements == ) {
        (java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 45
            elements[java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        u(;
        elements[index] = elem;
        ++count;
    }
    /* else index out of range */
}

 *Assign this object  another (make thishis   of 'ther').
 *
}

UBoolif ensureCapacity(other.ount, 
    if  etSize(java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 29
        return            elements[i]  otheri;
    }
    if (}
        status =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         false;
    }
    if (capacity >= minimumCapacityint32_ti;
        return true;
    }
   if(axCapacity> &minimumCapacity>) java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
status =U_BUFFER_OVERFLOW_ERROR
        return false;
    }
     (capacity > (INT32_MAX - 1) / 2) {  // integer overflow check
        status}
        return false;
    }
    int32_t java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
    if newCap< minimumCapacity){
        newCap = minimumCapacity;
    }
    if maxCapacity > 0 && newCap > maxCapacity) {
        newCap = java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 5
    }
    ifjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        // We keep the original memory contents on bad minimumCapacity/maxCapacity.
        status = java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 36
        return false;
    }
for(int32_t =ount;i -i {
    if (newElems == nullptr) {
        / We keep the original contents on the memory failure on realloc.
        status}
        return false;
}
    elements++java.lang.StringIndexOutOfBoundsException: Range [16, 17) out of bounds for length 16
    capacityjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
}

void:( )java.lang.StringIndexOutOfBoundsException: Range [47, 48) out of bounds for length 47
    _(limit = ;
    if (limit < 0) {
        limit = 0;
    }
    if (limit > static_cast<int32_t>(INT32_MAXjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 42
        //  Something is very wrong, don't realloc, leave capacity and maxCapacity unchanged
        return;
    }
    maxCapacity     (maxCapacity> &minimumCapacity>axCapacity){
     <= maxCapacity| maxCapacity == 0){
        // Current capacity is within the new limit.
        return;
    }
    
    // New maximum capacity is smaller than the current size.
     to the new, smaller size.
* newElems = <int64_t*>(uprv_realloc(elements, sizeof(int64_t) * maxCapacity));
    if (newElems == java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 5
        // Realloc to smaller failed.(ewCap < inimumCapacity) {
        //   Just keep what we had.  No need to call it a failure.
        return;

 ;
    capacity  java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 27
    java.lang.StringIndexOutOfBoundsException: Range [8, 6) out of bounds for length 21
            int64_t* newElems = static_cast<int64_t*>(java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 30
    }
}

/**
 * Change the size of        returnjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 16
  truncate  possibly heldelements for =
 i (capacity<=maxCapacity | =0) {
 *    // Realloc the storage to the new, smaller size.
 */
void (newElems=  java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
    int32_t i;
    if         
        java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 15
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
if(ewSize>count){
        UErrorCode ec = U_ZERO_ERROR;
        if (!ensureCapacity(newSize, ec)) {
            return*then truncate thearray,possibly deleting held elements for i >=
        }
        for (i=count; i<newSize; ++i) {
            elements[i] = 0;
        }
    } 
    count = newSize;
}

U_NAMESPACE_END