398 lines
11 KiB
C++
398 lines
11 KiB
C++
// © 2016 and later: Unicode, Inc. and others.
|
|
// License & terms of use: http://www.unicode.org/copyright.html
|
|
/*
|
|
**********************************************************************
|
|
* Copyright (c) 2002-2014, International Business Machines
|
|
* Corporation and others. All Rights Reserved.
|
|
**********************************************************************
|
|
* Author: Alan Liu
|
|
* Created: November 11 2002
|
|
* Since: ICU 2.4
|
|
**********************************************************************
|
|
*/
|
|
#include "utypeinfo.h" // for 'typeid' to work
|
|
|
|
#include "unicode/ustring.h"
|
|
#include "unicode/strenum.h"
|
|
#include "unicode/putil.h"
|
|
#include "uenumimp.h"
|
|
#include "ustrenum.h"
|
|
#include "cstring.h"
|
|
#include "cmemory.h"
|
|
#include "uassert.h"
|
|
|
|
U_NAMESPACE_BEGIN
|
|
// StringEnumeration implementation ---------------------------------------- ***
|
|
|
|
StringEnumeration::StringEnumeration()
|
|
: chars(charsBuffer), charsCapacity(sizeof(charsBuffer)) {
|
|
}
|
|
|
|
StringEnumeration::~StringEnumeration() {
|
|
if (chars != NULL && chars != charsBuffer) {
|
|
uprv_free(chars);
|
|
}
|
|
}
|
|
|
|
// StringEnumeration base class clone() default implementation, does not clone
|
|
StringEnumeration *
|
|
StringEnumeration::clone() const {
|
|
return NULL;
|
|
}
|
|
|
|
const char *
|
|
StringEnumeration::next(int32_t *resultLength, UErrorCode &status) {
|
|
const UnicodeString *s=snext(status);
|
|
if(U_SUCCESS(status) && s!=NULL) {
|
|
unistr=*s;
|
|
ensureCharsCapacity(unistr.length()+1, status);
|
|
if(U_SUCCESS(status)) {
|
|
if(resultLength!=NULL) {
|
|
*resultLength=unistr.length();
|
|
}
|
|
unistr.extract(0, INT32_MAX, chars, charsCapacity, US_INV);
|
|
return chars;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
const UChar *
|
|
StringEnumeration::unext(int32_t *resultLength, UErrorCode &status) {
|
|
const UnicodeString *s=snext(status);
|
|
if(U_SUCCESS(status) && s!=NULL) {
|
|
unistr=*s;
|
|
if(resultLength!=NULL) {
|
|
*resultLength=unistr.length();
|
|
}
|
|
return unistr.getTerminatedBuffer();
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
const UnicodeString *
|
|
StringEnumeration::snext(UErrorCode &status) {
|
|
int32_t length;
|
|
const char *s=next(&length, status);
|
|
return setChars(s, length, status);
|
|
}
|
|
|
|
void
|
|
StringEnumeration::ensureCharsCapacity(int32_t capacity, UErrorCode &status) {
|
|
if(U_SUCCESS(status) && capacity>charsCapacity) {
|
|
if(capacity<(charsCapacity+charsCapacity/2)) {
|
|
// avoid allocation thrashing
|
|
capacity=charsCapacity+charsCapacity/2;
|
|
}
|
|
if(chars!=charsBuffer) {
|
|
uprv_free(chars);
|
|
}
|
|
chars=(char *)uprv_malloc(capacity);
|
|
if(chars==NULL) {
|
|
chars=charsBuffer;
|
|
charsCapacity=sizeof(charsBuffer);
|
|
status=U_MEMORY_ALLOCATION_ERROR;
|
|
} else {
|
|
charsCapacity=capacity;
|
|
}
|
|
}
|
|
}
|
|
|
|
UnicodeString *
|
|
StringEnumeration::setChars(const char *s, int32_t length, UErrorCode &status) {
|
|
if(U_SUCCESS(status) && s!=NULL) {
|
|
if(length<0) {
|
|
length=(int32_t)uprv_strlen(s);
|
|
}
|
|
|
|
UChar *buffer=unistr.getBuffer(length+1);
|
|
if(buffer!=NULL) {
|
|
u_charsToUChars(s, buffer, length);
|
|
buffer[length]=0;
|
|
unistr.releaseBuffer(length);
|
|
return &unistr;
|
|
} else {
|
|
status=U_MEMORY_ALLOCATION_ERROR;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
UBool
|
|
StringEnumeration::operator==(const StringEnumeration& that)const {
|
|
return typeid(*this) == typeid(that);
|
|
}
|
|
|
|
UBool
|
|
StringEnumeration::operator!=(const StringEnumeration& that)const {
|
|
return !operator==(that);
|
|
}
|
|
|
|
// UStringEnumeration implementation --------------------------------------- ***
|
|
|
|
UStringEnumeration * U_EXPORT2
|
|
UStringEnumeration::fromUEnumeration(
|
|
UEnumeration *uenumToAdopt, UErrorCode &status) {
|
|
if (U_FAILURE(status)) {
|
|
uenum_close(uenumToAdopt);
|
|
return NULL;
|
|
}
|
|
UStringEnumeration *result = new UStringEnumeration(uenumToAdopt);
|
|
if (result == NULL) {
|
|
status = U_MEMORY_ALLOCATION_ERROR;
|
|
uenum_close(uenumToAdopt);
|
|
return NULL;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
UStringEnumeration::UStringEnumeration(UEnumeration* _uenum) :
|
|
uenum(_uenum) {
|
|
U_ASSERT(_uenum != 0);
|
|
}
|
|
|
|
UStringEnumeration::~UStringEnumeration() {
|
|
uenum_close(uenum);
|
|
}
|
|
|
|
int32_t UStringEnumeration::count(UErrorCode& status) const {
|
|
return uenum_count(uenum, &status);
|
|
}
|
|
|
|
const char *UStringEnumeration::next(int32_t *resultLength, UErrorCode &status) {
|
|
return uenum_next(uenum, resultLength, &status);
|
|
}
|
|
|
|
const UnicodeString* UStringEnumeration::snext(UErrorCode& status) {
|
|
int32_t length;
|
|
const UChar* str = uenum_unext(uenum, &length, &status);
|
|
if (str == 0 || U_FAILURE(status)) {
|
|
return 0;
|
|
}
|
|
return &unistr.setTo(str, length);
|
|
}
|
|
|
|
void UStringEnumeration::reset(UErrorCode& status) {
|
|
uenum_reset(uenum, &status);
|
|
}
|
|
|
|
UOBJECT_DEFINE_RTTI_IMPLEMENTATION(UStringEnumeration)
|
|
U_NAMESPACE_END
|
|
|
|
// C wrapper --------------------------------------------------------------- ***
|
|
|
|
#define THIS(en) ((icu::StringEnumeration*)(en->context))
|
|
|
|
U_CDECL_BEGIN
|
|
|
|
/**
|
|
* Wrapper API to make StringEnumeration look like UEnumeration.
|
|
*/
|
|
static void U_CALLCONV
|
|
ustrenum_close(UEnumeration* en) {
|
|
delete THIS(en);
|
|
uprv_free(en);
|
|
}
|
|
|
|
/**
|
|
* Wrapper API to make StringEnumeration look like UEnumeration.
|
|
*/
|
|
static int32_t U_CALLCONV
|
|
ustrenum_count(UEnumeration* en,
|
|
UErrorCode* ec)
|
|
{
|
|
return THIS(en)->count(*ec);
|
|
}
|
|
|
|
/**
|
|
* Wrapper API to make StringEnumeration look like UEnumeration.
|
|
*/
|
|
static const UChar* U_CALLCONV
|
|
ustrenum_unext(UEnumeration* en,
|
|
int32_t* resultLength,
|
|
UErrorCode* ec)
|
|
{
|
|
return THIS(en)->unext(resultLength, *ec);
|
|
}
|
|
|
|
/**
|
|
* Wrapper API to make StringEnumeration look like UEnumeration.
|
|
*/
|
|
static const char* U_CALLCONV
|
|
ustrenum_next(UEnumeration* en,
|
|
int32_t* resultLength,
|
|
UErrorCode* ec)
|
|
{
|
|
return THIS(en)->next(resultLength, *ec);
|
|
}
|
|
|
|
/**
|
|
* Wrapper API to make StringEnumeration look like UEnumeration.
|
|
*/
|
|
static void U_CALLCONV
|
|
ustrenum_reset(UEnumeration* en,
|
|
UErrorCode* ec)
|
|
{
|
|
THIS(en)->reset(*ec);
|
|
}
|
|
|
|
/**
|
|
* Pseudo-vtable for UEnumeration wrapper around StringEnumeration.
|
|
* The StringEnumeration pointer will be stored in 'context'.
|
|
*/
|
|
static const UEnumeration USTRENUM_VT = {
|
|
NULL,
|
|
NULL, // store StringEnumeration pointer here
|
|
ustrenum_close,
|
|
ustrenum_count,
|
|
ustrenum_unext,
|
|
ustrenum_next,
|
|
ustrenum_reset
|
|
};
|
|
|
|
U_CDECL_END
|
|
|
|
/**
|
|
* Given a StringEnumeration, wrap it in a UEnumeration. The
|
|
* StringEnumeration is adopted; after this call, the caller must not
|
|
* delete it (regardless of error status).
|
|
*/
|
|
U_CAPI UEnumeration* U_EXPORT2
|
|
uenum_openFromStringEnumeration(icu::StringEnumeration* adopted, UErrorCode* ec) {
|
|
UEnumeration* result = NULL;
|
|
if (U_SUCCESS(*ec) && adopted != NULL) {
|
|
result = (UEnumeration*) uprv_malloc(sizeof(UEnumeration));
|
|
if (result == NULL) {
|
|
*ec = U_MEMORY_ALLOCATION_ERROR;
|
|
} else {
|
|
uprv_memcpy(result, &USTRENUM_VT, sizeof(USTRENUM_VT));
|
|
result->context = adopted;
|
|
}
|
|
}
|
|
if (result == NULL) {
|
|
delete adopted;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// C wrapper --------------------------------------------------------------- ***
|
|
|
|
U_CDECL_BEGIN
|
|
|
|
typedef struct UCharStringEnumeration {
|
|
UEnumeration uenum;
|
|
int32_t index, count;
|
|
} UCharStringEnumeration;
|
|
|
|
static void U_CALLCONV
|
|
ucharstrenum_close(UEnumeration* en) {
|
|
uprv_free(en);
|
|
}
|
|
|
|
static int32_t U_CALLCONV
|
|
ucharstrenum_count(UEnumeration* en,
|
|
UErrorCode* /*ec*/) {
|
|
return ((UCharStringEnumeration*)en)->count;
|
|
}
|
|
|
|
static const UChar* U_CALLCONV
|
|
ucharstrenum_unext(UEnumeration* en,
|
|
int32_t* resultLength,
|
|
UErrorCode* /*ec*/) {
|
|
UCharStringEnumeration *e = (UCharStringEnumeration*) en;
|
|
if (e->index >= e->count) {
|
|
return NULL;
|
|
}
|
|
const UChar* result = ((const UChar**)e->uenum.context)[e->index++];
|
|
if (resultLength) {
|
|
*resultLength = (int32_t)u_strlen(result);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
static const char* U_CALLCONV
|
|
ucharstrenum_next(UEnumeration* en,
|
|
int32_t* resultLength,
|
|
UErrorCode* /*ec*/) {
|
|
UCharStringEnumeration *e = (UCharStringEnumeration*) en;
|
|
if (e->index >= e->count) {
|
|
return NULL;
|
|
}
|
|
const char* result = ((const char**)e->uenum.context)[e->index++];
|
|
if (resultLength) {
|
|
*resultLength = (int32_t)uprv_strlen(result);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static void U_CALLCONV
|
|
ucharstrenum_reset(UEnumeration* en,
|
|
UErrorCode* /*ec*/) {
|
|
((UCharStringEnumeration*)en)->index = 0;
|
|
}
|
|
|
|
static const UEnumeration UCHARSTRENUM_VT = {
|
|
NULL,
|
|
NULL, // store StringEnumeration pointer here
|
|
ucharstrenum_close,
|
|
ucharstrenum_count,
|
|
uenum_unextDefault,
|
|
ucharstrenum_next,
|
|
ucharstrenum_reset
|
|
};
|
|
|
|
static const UEnumeration UCHARSTRENUM_U_VT = {
|
|
NULL,
|
|
NULL, // store StringEnumeration pointer here
|
|
ucharstrenum_close,
|
|
ucharstrenum_count,
|
|
ucharstrenum_unext,
|
|
uenum_nextDefault,
|
|
ucharstrenum_reset
|
|
};
|
|
|
|
U_CDECL_END
|
|
|
|
U_CAPI UEnumeration* U_EXPORT2
|
|
uenum_openCharStringsEnumeration(const char* const strings[], int32_t count,
|
|
UErrorCode* ec) {
|
|
UCharStringEnumeration* result = NULL;
|
|
if (U_SUCCESS(*ec) && count >= 0 && (count == 0 || strings != 0)) {
|
|
result = (UCharStringEnumeration*) uprv_malloc(sizeof(UCharStringEnumeration));
|
|
if (result == NULL) {
|
|
*ec = U_MEMORY_ALLOCATION_ERROR;
|
|
} else {
|
|
U_ASSERT((char*)result==(char*)(&result->uenum));
|
|
uprv_memcpy(result, &UCHARSTRENUM_VT, sizeof(UCHARSTRENUM_VT));
|
|
result->uenum.context = (void*)strings;
|
|
result->index = 0;
|
|
result->count = count;
|
|
}
|
|
}
|
|
return (UEnumeration*) result;
|
|
}
|
|
|
|
U_CAPI UEnumeration* U_EXPORT2
|
|
uenum_openUCharStringsEnumeration(const UChar* const strings[], int32_t count,
|
|
UErrorCode* ec) {
|
|
UCharStringEnumeration* result = NULL;
|
|
if (U_SUCCESS(*ec) && count >= 0 && (count == 0 || strings != 0)) {
|
|
result = (UCharStringEnumeration*) uprv_malloc(sizeof(UCharStringEnumeration));
|
|
if (result == NULL) {
|
|
*ec = U_MEMORY_ALLOCATION_ERROR;
|
|
} else {
|
|
U_ASSERT((char*)result==(char*)(&result->uenum));
|
|
uprv_memcpy(result, &UCHARSTRENUM_U_VT, sizeof(UCHARSTRENUM_U_VT));
|
|
result->uenum.context = (void*)strings;
|
|
result->index = 0;
|
|
result->count = count;
|
|
}
|
|
}
|
|
return (UEnumeration*) result;
|
|
}
|
|
|
|
|
|
// end C Wrapper
|