icuSources/common/ustrenum.cpp

   1 /*
   2 **********************************************************************
   3 * Copyright (c) 2002-2012, International Business Machines
   4 * Corporation and others.  All Rights Reserved.
   5 **********************************************************************
   6 * Author: Alan Liu
   7 * Created: November 11 2002
   8 * Since: ICU 2.4
   9 **********************************************************************
  10 */
  11 #include "utypeinfo.h"  // for 'typeid' to work
  12
  13 #include "unicode/ustring.h"
  14 #include "unicode/strenum.h"
  15 #include "unicode/putil.h"
  16 #include "uenumimp.h"
  17 #include "ustrenum.h"
  18 #include "cstring.h"
  19 #include "cmemory.h"
  20 #include "uassert.h"
  21
  22 U_NAMESPACE_BEGIN
  23 // StringEnumeration implementation ---------------------------------------- ***
  24
  25 StringEnumeration::StringEnumeration()
  26     : chars(charsBuffer), charsCapacity(sizeof(charsBuffer)) {
  27 }
  28
  29 StringEnumeration::~StringEnumeration() {
  30     if (chars != NULL && chars != charsBuffer) {
  31         uprv_free(chars);
  32     }
  33 }
  34
  35 // StringEnumeration base class clone() default implementation, does not clone
  36 StringEnumeration *
  37 StringEnumeration::clone() const {
  38   return NULL;
  39 }
  40
  41 const char *
  42 StringEnumeration::next(int32_t *resultLength, UErrorCode &status) {
  43     const UnicodeString *s=snext(status);
  44     if(U_SUCCESS(status) && s!=NULL) {
  45         unistr=*s;
  46         ensureCharsCapacity(unistr.length()+1, status);
  47         if(U_SUCCESS(status)) {
  48             if(resultLength!=NULL) {
  49                 *resultLength=unistr.length();
  50             }
  51             unistr.extract(0, INT32_MAX, chars, charsCapacity, US_INV);
  52             return chars;
  53         }
  54     }
  55
  56     return NULL;
  57 }
  58
  59 const UChar *
  60 StringEnumeration::unext(int32_t *resultLength, UErrorCode &status) {
  61     const UnicodeString *s=snext(status);
  62     if(U_SUCCESS(status) && s!=NULL) {
  63         unistr=*s;
  64         if(resultLength!=NULL) {
  65             *resultLength=unistr.length();
  66         }
  67         return unistr.getTerminatedBuffer();
  68     }
  69
  70     return NULL;
  71 }
  72
  73 const UnicodeString *
  74 StringEnumeration::snext(UErrorCode &status) {
  75     int32_t length;
  76     const char *s=next(&length, status);
  77     return setChars(s, length, status);
  78 }
  79
  80 void
  81 StringEnumeration::ensureCharsCapacity(int32_t capacity, UErrorCode &status) {
  82     if(U_SUCCESS(status) && capacity>charsCapacity) {
  83         if(capacity<(charsCapacity+charsCapacity/2)) {
  84             // avoid allocation thrashing
  85             capacity=charsCapacity+charsCapacity/2;
  86         }
  87         if(chars!=charsBuffer) {
  88             uprv_free(chars);
  89         }
  90         chars=(char *)uprv_malloc(capacity);
  91         if(chars==NULL) {
  92             chars=charsBuffer;
  93             charsCapacity=sizeof(charsBuffer);
  94             status=U_MEMORY_ALLOCATION_ERROR;
  95         } else {
  96             charsCapacity=capacity;
  97         }
  98     }
  99 }
 100
 101 UnicodeString *
 102 StringEnumeration::setChars(const char *s, int32_t length, UErrorCode &status) {
 103     if(U_SUCCESS(status) && s!=NULL) {
 104         if(length<0) {
 105             length=(int32_t)uprv_strlen(s);
 106         }
 107
 108         UChar *buffer=unistr.getBuffer(length+1);
 109         if(buffer!=NULL) {
 110             u_charsToUChars(s, buffer, length);
 111             buffer[length]=0;
 112             unistr.releaseBuffer(length);
 113             return &unistr;
 114         } else {
 115             status=U_MEMORY_ALLOCATION_ERROR;
 116         }
 117     }
 118
 119     return NULL;
 120 }
 121 UBool
 122 StringEnumeration::operator==(const StringEnumeration& that)const {
 123     return typeid(*this) == typeid(that);
 124 }
 125
 126 UBool
 127 StringEnumeration::operator!=(const StringEnumeration& that)const {
 128     return !operator==(that);
 129 }
 130
 131 // UStringEnumeration implementation --------------------------------------- ***
 132
 133 UStringEnumeration::UStringEnumeration(UEnumeration* _uenum) :
 134     uenum(_uenum) {
 135     U_ASSERT(_uenum != 0);
 136 }
 137
 138 UStringEnumeration::~UStringEnumeration() {
 139     uenum_close(uenum);
 140 }
 141
 142 int32_t UStringEnumeration::count(UErrorCode& status) const {
 143     return uenum_count(uenum, &status);
 144 }
 145
 146 const char *UStringEnumeration::next(int32_t *resultLength, UErrorCode &status) {
 147     return uenum_next(uenum, resultLength, &status);
 148 }
 149
 150 const UnicodeString* UStringEnumeration::snext(UErrorCode& status) {
 151     int32_t length;
 152     const UChar* str = uenum_unext(uenum, &length, &status);
 153     if (str == 0 || U_FAILURE(status)) {
 154         return 0;
 155     }
 156     return &unistr.setTo(str, length);
 157 }
 158
 159 void UStringEnumeration::reset(UErrorCode& status) {
 160     uenum_reset(uenum, &status);
 161 }
 162
 163 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(UStringEnumeration)
 164 U_NAMESPACE_END
 165
 166 // C wrapper --------------------------------------------------------------- ***
 167
 168 #define THIS(en) ((icu::StringEnumeration*)(en->context))
 169
 170 U_CDECL_BEGIN
 171
 172 /**
 173  * Wrapper API to make StringEnumeration look like UEnumeration.
 174  */
 175 static void U_CALLCONV
 176 ustrenum_close(UEnumeration* en) {
 177     delete THIS(en);
 178     uprv_free(en);
 179 }
 180
 181 /**
 182  * Wrapper API to make StringEnumeration look like UEnumeration.
 183  */
 184 static int32_t U_CALLCONV
 185 ustrenum_count(UEnumeration* en,
 186                UErrorCode* ec)
 187 {
 188     return THIS(en)->count(*ec);
 189 }
 190
 191 /**
 192  * Wrapper API to make StringEnumeration look like UEnumeration.
 193  */
 194 static const UChar* U_CALLCONV
 195 ustrenum_unext(UEnumeration* en,
 196                int32_t* resultLength,
 197                UErrorCode* ec)
 198 {
 199     return THIS(en)->unext(resultLength, *ec);
 200 }
 201
 202 /**
 203  * Wrapper API to make StringEnumeration look like UEnumeration.
 204  */
 205 static const char* U_CALLCONV
 206 ustrenum_next(UEnumeration* en,
 207               int32_t* resultLength,
 208               UErrorCode* ec)
 209 {
 210     return THIS(en)->next(resultLength, *ec);
 211 }
 212
 213 /**
 214  * Wrapper API to make StringEnumeration look like UEnumeration.
 215  */
 216 static void U_CALLCONV
 217 ustrenum_reset(UEnumeration* en,
 218                UErrorCode* ec)
 219 {
 220     THIS(en)->reset(*ec);
 221 }
 222
 223 /**
 224  * Pseudo-vtable for UEnumeration wrapper around StringEnumeration.
 225  * The StringEnumeration pointer will be stored in 'context'.
 226  */
 227 static const UEnumeration USTRENUM_VT = {
 228     NULL,
 229     NULL, // store StringEnumeration pointer here
 230     ustrenum_close,
 231     ustrenum_count,
 232     ustrenum_unext,
 233     ustrenum_next,
 234     ustrenum_reset
 235 };
 236
 237 U_CDECL_END
 238
 239 /**
 240  * Given a StringEnumeration, wrap it in a UEnumeration.  The
 241  * StringEnumeration is adopted; after this call, the caller must not
 242  * delete it (regardless of error status).
 243  */
 244 U_CAPI UEnumeration* U_EXPORT2
 245 uenum_openFromStringEnumeration(icu::StringEnumeration* adopted, UErrorCode* ec) {
 246     UEnumeration* result = NULL;
 247     if (U_SUCCESS(*ec) && adopted != NULL) {
 248         result = (UEnumeration*) uprv_malloc(sizeof(UEnumeration));
 249         if (result == NULL) {
 250             *ec = U_MEMORY_ALLOCATION_ERROR;
 251         } else {
 252             uprv_memcpy(result, &USTRENUM_VT, sizeof(USTRENUM_VT));
 253             result->context = adopted;
 254         }
 255     }
 256     if (result == NULL) {
 257         delete adopted;
 258     }
 259     return result;
 260 }
 261
 262 // C wrapper --------------------------------------------------------------- ***
 263
 264 U_CDECL_BEGIN
 265
 266 typedef struct UCharStringEnumeration {
 267     UEnumeration uenum;
 268     int32_t index, count;
 269 } UCharStringEnumeration;
 270
 271 static void U_CALLCONV
 272 ucharstrenum_close(UEnumeration* en) {
 273     uprv_free(en);
 274 }
 275
 276 static int32_t U_CALLCONV
 277 ucharstrenum_count(UEnumeration* en,
 278                    UErrorCode* /*ec*/) {
 279     return ((UCharStringEnumeration*)en)->count;
 280 }
 281
 282 static const UChar* U_CALLCONV
 283 ucharstrenum_unext(UEnumeration* en,
 284                   int32_t* resultLength,
 285                   UErrorCode* /*ec*/) {
 286     UCharStringEnumeration *e = (UCharStringEnumeration*) en;
 287     if (e->index >= e->count) {
 288         return NULL;
 289     }
 290     const UChar* result = ((const UChar**)e->uenum.context)[e->index++];
 291     if (resultLength) {
 292         *resultLength = (int32_t)u_strlen(result);
 293     }
 294     return result;
 295 }
 296
 297
 298 static const char* U_CALLCONV
 299 ucharstrenum_next(UEnumeration* en,
 300                   int32_t* resultLength,
 301                   UErrorCode* /*ec*/) {
 302     UCharStringEnumeration *e = (UCharStringEnumeration*) en;
 303     if (e->index >= e->count) {
 304         return NULL;
 305     }
 306     const char* result = ((const char**)e->uenum.context)[e->index++];
 307     if (resultLength) {
 308         *resultLength = (int32_t)uprv_strlen(result);
 309     }
 310     return result;
 311 }
 312
 313 static void U_CALLCONV
 314 ucharstrenum_reset(UEnumeration* en,
 315                    UErrorCode* /*ec*/) {
 316     ((UCharStringEnumeration*)en)->index = 0;
 317 }
 318
 319 static const UEnumeration UCHARSTRENUM_VT = {
 320     NULL,
 321     NULL, // store StringEnumeration pointer here
 322     ucharstrenum_close,
 323     ucharstrenum_count,
 324     uenum_unextDefault,
 325     ucharstrenum_next,
 326     ucharstrenum_reset
 327 };
 328
 329 static const UEnumeration UCHARSTRENUM_U_VT = {
 330     NULL,
 331     NULL, // store StringEnumeration pointer here
 332     ucharstrenum_close,
 333     ucharstrenum_count,
 334     ucharstrenum_unext,
 335     uenum_nextDefault,
 336     ucharstrenum_reset
 337 };
 338
 339 U_CDECL_END
 340
 341 U_CAPI UEnumeration* U_EXPORT2
 342 uenum_openCharStringsEnumeration(const char* const strings[], int32_t count,
 343                                  UErrorCode* ec) {
 344     UCharStringEnumeration* result = NULL;
 345     if (U_SUCCESS(*ec) && count >= 0 && (count == 0 || strings != 0)) {
 346         result = (UCharStringEnumeration*) uprv_malloc(sizeof(UCharStringEnumeration));
 347         if (result == NULL) {
 348             *ec = U_MEMORY_ALLOCATION_ERROR;
 349         } else {
 350             U_ASSERT((char*)result==(char*)(&result->uenum));
 351             uprv_memcpy(result, &UCHARSTRENUM_VT, sizeof(UCHARSTRENUM_VT));
 352             result->uenum.context = (void*)strings;
 353             result->index = 0;
 354             result->count = count;
 355         }
 356     }
 357     return (UEnumeration*) result;
 358 }
 359
 360 U_CAPI UEnumeration* U_EXPORT2
 361 uenum_openUCharStringsEnumeration(const UChar* const strings[], int32_t count,
 362                                  UErrorCode* ec) {
 363     UCharStringEnumeration* result = NULL;
 364     if (U_SUCCESS(*ec) && count >= 0 && (count == 0 || strings != 0)) {
 365         result = (UCharStringEnumeration*) uprv_malloc(sizeof(UCharStringEnumeration));
 366         if (result == NULL) {
 367             *ec = U_MEMORY_ALLOCATION_ERROR;
 368         } else {
 369             U_ASSERT((char*)result==(char*)(&result->uenum));
 370             uprv_memcpy(result, &UCHARSTRENUM_U_VT, sizeof(UCHARSTRENUM_U_VT));
 371             result->uenum.context = (void*)strings;
 372             result->index = 0;
 373             result->count = count;
 374         }
 375     }
 376     return (UEnumeration*) result;
 377 }
 378
 379
 380 // end C Wrapper