Restoring authorship annotation for <[email protected]>. Commit 2 of 2.

1 files changed, 396 insertions, 396 deletions

diff --git a/contrib/libs/icu/common/ustrenum.cpp b/contrib/libs/icu/common/ustrenum.cpp
index d3bb4794d9a..ed23eaa232e 100644
--- a/contrib/libs/icu/common/ustrenum.cpp
+++ b/contrib/libs/icu/common/ustrenum.cpp
@@ -1,398 +1,398 @@
 // © 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);  
-} 
- 
+// 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 !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 
+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