| // © 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 | |
| ********************************************************************** | |
| */ | |
| #if defined(STARBOARD) | |
| #include "starboard/client_porting/poem/assert_poem.h" | |
| #endif // defined(STARBOARD) | |
| #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 |