ICU-64252.0.1.tar.gz

[apple/icu.git] / icuSources / i18n / utrans.cpp

diff --git a/icuSources/i18n/utrans.cpp b/icuSources/i18n/utrans.cpp
index ff1a3637067377a4bb56a47a48c6200fa991c61e..29013ead1257c239755aaa554a28a1158969100f 100644 (file)
--- a/icuSources/i18n/utrans.cpp
+++ b/icuSources/i18n/utrans.cpp
@@ -1,12 +1,14 @@
+// © 2016 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html

 /*
 /*

-*******************************************************************************
-*   Copyright (C) 1997-2003, International Business Machines
-*   Corporation and others.  All Rights Reserved.
-*******************************************************************************
-*   Date        Name        Description
-*   06/21/00    aliu        Creation.
-*******************************************************************************
-*/
+ *******************************************************************************
+ *   Copyright (C) 1997-2009,2014 International Business Machines
+ *   Corporation and others.  All Rights Reserved.
+ *******************************************************************************
+ *   Date        Name        Description
+ *   06/21/00    aliu        Creation.
+ *******************************************************************************
+ */

 
 #include "unicode/utypes.h"
 
 
 #include "unicode/utypes.h"
 


@@ -19,6 +21,9 @@
 #include "unicode/unifilt.h"
 #include "unicode/uniset.h"
 #include "unicode/ustring.h"
 #include "unicode/unifilt.h"
 #include "unicode/uniset.h"
 #include "unicode/ustring.h"

+#include "unicode/uenum.h"
+#include "unicode/uset.h"
+#include "uenumimp.h"

 #include "cpputils.h"
 #include "rbt.h"
 
 #include "cpputils.h"
 #include "rbt.h"
 


@@ -36,18 +41,12 @@ U_NAMESPACE_BEGIN
 class ReplaceableGlue : public Replaceable {
 
     UReplaceable *rep;
 class ReplaceableGlue : public Replaceable {
 
     UReplaceable *rep;

-    UReplaceableCallbacks *func;
-
-    /**
-     * The address of this static class variable serves as this class's ID
-     * for ICU "poor man's RTTI".
-     */
-    static const char fgClassID;
+    const UReplaceableCallbacks *func;

 
 public:
 
     ReplaceableGlue(UReplaceable *replaceable,
 
 public:
 
     ReplaceableGlue(UReplaceable *replaceable,

-                    UReplaceableCallbacks *funcCallback);
+                    const UReplaceableCallbacks *funcCallback);

 
     virtual ~ReplaceableGlue();
 
 
     virtual ~ReplaceableGlue();
 


@@ -68,14 +67,14 @@ public:
      *
      * @draft ICU 2.2
      */
      *
      * @draft ICU 2.2
      */

-    virtual inline UClassID getDynamicClassID() const { return getStaticClassID(); }
+    virtual UClassID getDynamicClassID() const;

 
     /**
      * ICU "poor man's RTTI", returns a UClassID for this class.
      *
      * @draft ICU 2.2
      */
 
     /**
      * ICU "poor man's RTTI", returns a UClassID for this class.
      *
      * @draft ICU 2.2
      */

-    static inline UClassID getStaticClassID() { return (UClassID)&fgClassID; }
+    static UClassID U_EXPORT2 getStaticClassID();

 
 protected:
 
 
 protected:
 


@@ -86,11 +85,10 @@ protected:
     virtual UChar32 getChar32At(int32_t offset) const;
 };
 
     virtual UChar32 getChar32At(int32_t offset) const;
 };
 

-
-const char ReplaceableGlue::fgClassID=0;
+UOBJECT_DEFINE_RTTI_IMPLEMENTATION(ReplaceableGlue)

 
 ReplaceableGlue::ReplaceableGlue(UReplaceable *replaceable,
 
 ReplaceableGlue::ReplaceableGlue(UReplaceable *replaceable,

-                                 UReplaceableCallbacks *funcCallback)
+                                 const UReplaceableCallbacks *funcCallback)

   : Replaceable()
 {
     this->rep = replaceable;
   : Replaceable()
 {
     this->rep = replaceable;


@@ -132,84 +130,18 @@ U_NAMESPACE_END
  * General API
  ********************************************************************/
 U_NAMESPACE_USE
  * General API
  ********************************************************************/
 U_NAMESPACE_USE

-#if 0
-
-U_CAPI UTransliterator*
-utrans_open(const char* id,
-            UTransDirection dir,
-            UParseError* parseError,
-            UErrorCode* status) {
-
-    utrans_ENTRY(status) NULL;
-
-    if (id == NULL) {
-        *status = U_ILLEGAL_ARGUMENT_ERROR;
-        return NULL;
-    }
-
-    UnicodeString ID(id, ""); // use invariant converter
-    Transliterator *trans = NULL;
-
-    trans = Transliterator::createInstance(ID, dir, *parseError, *status);
-
-    if (trans == NULL) {
-        *status = U_ILLEGAL_ARGUMENT_ERROR;
-    }
-    return (UTransliterator*) trans;
-}
-
-U_CAPI UTransliterator*
-utrans_openRules(const char* id,
-                 const UChar* rules,
-                 int32_t rulesLength, /* -1 if null-terminated */
-                 UTransDirection dir,
-                 UParseError* parseErr, /* may be NULL */
-                 UErrorCode* status) {

 
 

-    utrans_ENTRY(status) NULL;
-
-    if (id == NULL || rules == NULL) {
-        *status = U_ILLEGAL_ARGUMENT_ERROR;
+U_CAPI UTransliterator* U_EXPORT2
+utrans_openU(const UChar *id,
+             int32_t idLength,
+             UTransDirection dir,
+             const UChar *rules,
+             int32_t rulesLength,
+             UParseError *parseError,
+             UErrorCode *status) {
+    if(status==NULL || U_FAILURE(*status)) {

         return NULL;
     }
         return NULL;
     }

-
-    UnicodeString ID(id, ""); // use invariant converter
-    UnicodeString ruleStr(rulesLength < 0,
-                          rules,
-                          rulesLength); // r-o alias
-
-    RuleBasedTransliterator *trans = NULL;
-
-    // Use if() to avoid construction of ParseError object on stack
-    // unless it is called for by user.
-    if (parseErr != NULL) {
-        trans = new RuleBasedTransliterator(ID, ruleStr, dir,
-                                            NULL, *parseErr, *status);
-    } else {
-        trans = new RuleBasedTransliterator(ID, ruleStr, dir,
-                                            NULL, *status);
-    }
-
-    if (trans == NULL) {
-        *status = U_MEMORY_ALLOCATION_ERROR;
-    } else if (U_FAILURE(*status)) {
-        delete trans;
-        trans = NULL;
-    }
-    return (UTransliterator*) trans;
-}
-#endif
-
-U_CAPI UTransliterator* U_EXPORT2
-utrans_open(const char* id,
-            UTransDirection dir,
-            const UChar* rules,         /* may be Null */
-            int32_t rulesLength,        /* -1 if null-terminated */ 
-            UParseError* parseError,    /* may be Null */
-            UErrorCode* status) {
-
-    utrans_ENTRY(status) NULL;
-

     if (id == NULL) {
         *status = U_ILLEGAL_ARGUMENT_ERROR;
         return NULL;
     if (id == NULL) {
         *status = U_ILLEGAL_ARGUMENT_ERROR;
         return NULL;


@@ -220,7 +152,7 @@ utrans_open(const char* id,
         parseError = &temp;
     }
     
         parseError = &temp;
     }
     

-    UnicodeString ID(id, ""); // use invariant converter
+    UnicodeString ID(idLength<0, id, idLength); // r-o alias

 
     if(rules==NULL){
 
 
     if(rules==NULL){
 


@@ -237,19 +169,29 @@ utrans_open(const char* id,
                               rules,
                               rulesLength); // r-o alias
 
                               rules,
                               rulesLength); // r-o alias
 

-        RuleBasedTransliterator *trans = NULL;
-        trans = new RuleBasedTransliterator(ID, ruleStr, dir,
-                                            NULL, *parseError, *status);
-        if (trans == NULL) {
-            *status = U_MEMORY_ALLOCATION_ERROR;
-        } else if (U_FAILURE(*status)) {
-            delete trans;
-            trans = NULL;
+        Transliterator *trans = NULL;
+        trans = Transliterator::createFromRules(ID, ruleStr, dir, *parseError, *status); 
+        if(U_FAILURE(*status)) { 
+            return NULL;

         }
         }

+

         return (UTransliterator*) trans;
     }
 }
 
         return (UTransliterator*) trans;
     }
 }
 

+U_CAPI UTransliterator* U_EXPORT2
+utrans_open(const char* id,
+            UTransDirection dir,
+            const UChar* rules,         /* may be Null */
+            int32_t rulesLength,        /* -1 if null-terminated */ 
+            UParseError* parseError,    /* may be Null */
+            UErrorCode* status) {
+    UnicodeString ID(id, -1, US_INV); // use invariant converter
+    return utrans_openU(ID.getBuffer(), ID.length(), dir,
+                        rules, rulesLength,
+                        parseError, status);
+}
+

 U_CAPI UTransliterator* U_EXPORT2
 utrans_openInverse(const UTransliterator* trans,
                    UErrorCode* status) {
 U_CAPI UTransliterator* U_EXPORT2
 utrans_openInverse(const UTransliterator* trans,
                    UErrorCode* status) {


@@ -285,11 +227,22 @@ utrans_close(UTransliterator* trans) {
     delete (Transliterator*) trans;
 }
 
     delete (Transliterator*) trans;
 }
 

+U_CAPI const UChar * U_EXPORT2
+utrans_getUnicodeID(const UTransliterator *trans,
+                    int32_t *resultLength) {
+    // Transliterator keeps its ID NUL-terminated
+    const UnicodeString &ID=((Transliterator*) trans)->getID();
+    if(resultLength!=NULL) {
+        *resultLength=ID.length();
+    }
+    return ID.getBuffer();
+}
+

 U_CAPI int32_t U_EXPORT2
 utrans_getID(const UTransliterator* trans,
              char* buf,
              int32_t bufCapacity) {
 U_CAPI int32_t U_EXPORT2
 utrans_getID(const UTransliterator* trans,
              char* buf,
              int32_t bufCapacity) {

-    return ((Transliterator*) trans)->getID().extract(0, 0x7fffffff, buf, bufCapacity, "");
+    return ((Transliterator*) trans)->getID().extract(0, 0x7fffffff, buf, bufCapacity, US_INV);

 }
 
 U_CAPI void U_EXPORT2
 }
 
 U_CAPI void U_EXPORT2


@@ -300,9 +253,15 @@ utrans_register(UTransliterator* adoptedTrans,
     Transliterator::registerInstance((Transliterator*) adoptedTrans);
 }
 
     Transliterator::registerInstance((Transliterator*) adoptedTrans);
 }
 

+U_CAPI void U_EXPORT2
+utrans_unregisterID(const UChar* id, int32_t idLength) {
+    UnicodeString ID(idLength<0, id, idLength); // r-o alias
+    Transliterator::unregister(ID);
+}
+

 U_CAPI void U_EXPORT2
 utrans_unregister(const char* id) {
 U_CAPI void U_EXPORT2
 utrans_unregister(const char* id) {

-    UnicodeString ID(id, ""); // use invariant converter
+    UnicodeString ID(id, -1, US_INV); // use invariant converter

     Transliterator::unregister(ID);
 }
 
     Transliterator::unregister(ID);
 }
 


@@ -340,7 +299,96 @@ U_CAPI int32_t U_EXPORT2
 utrans_getAvailableID(int32_t index,
                       char* buf, // may be NULL
                       int32_t bufCapacity) {
 utrans_getAvailableID(int32_t index,
                       char* buf, // may be NULL
                       int32_t bufCapacity) {

-    return Transliterator::getAvailableID(index).extract(0, 0x7fffffff, buf, bufCapacity, "");
+    return Transliterator::getAvailableID(index).extract(0, 0x7fffffff, buf, bufCapacity, US_INV);
+}
+
+/* Transliterator UEnumeration ---------------------------------------------- */
+
+typedef struct UTransEnumeration {
+    UEnumeration uenum;
+    int32_t index, count;
+} UTransEnumeration;
+
+U_CDECL_BEGIN
+static int32_t U_CALLCONV
+utrans_enum_count(UEnumeration *uenum, UErrorCode *pErrorCode) {
+    if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
+        return 0;
+    }
+    return ((UTransEnumeration *)uenum)->count;
+}
+
+static const UChar* U_CALLCONV
+utrans_enum_unext(UEnumeration *uenum,
+                  int32_t* resultLength,
+                  UErrorCode *pErrorCode) {
+    if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
+        return 0;
+    }
+
+    UTransEnumeration *ute=(UTransEnumeration *)uenum;
+    int32_t index=ute->index;
+    if(index<ute->count) {
+        const UnicodeString &ID=Transliterator::getAvailableID(index);
+        ute->index=index+1;
+        if(resultLength!=NULL) {
+            *resultLength=ID.length();
+        }
+        // Transliterator keeps its ID NUL-terminated
+        return ID.getBuffer();
+    }
+
+    if(resultLength!=NULL) {
+        *resultLength=0;
+    }
+    return NULL;
+}
+
+static void U_CALLCONV
+utrans_enum_reset(UEnumeration *uenum, UErrorCode *pErrorCode) {
+    if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
+        return;
+    }
+
+    UTransEnumeration *ute=(UTransEnumeration *)uenum;
+    ute->index=0;
+    ute->count=Transliterator::countAvailableIDs();
+}
+
+static void U_CALLCONV
+utrans_enum_close(UEnumeration *uenum) {
+    uprv_free(uenum);
+}
+U_CDECL_END
+
+static const UEnumeration utransEnumeration={
+    NULL,
+    NULL,
+    utrans_enum_close,
+    utrans_enum_count,
+    utrans_enum_unext,
+    uenum_nextDefault,
+    utrans_enum_reset
+};
+
+U_CAPI UEnumeration * U_EXPORT2
+utrans_openIDs(UErrorCode *pErrorCode) {
+    UTransEnumeration *ute;
+
+    if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
+        return NULL;
+    }
+
+    ute=(UTransEnumeration *)uprv_malloc(sizeof(UTransEnumeration));
+    if(ute==NULL) {
+        *pErrorCode=U_MEMORY_ALLOCATION_ERROR;
+        return NULL;
+    }
+
+    ute->uenum=utransEnumeration;
+    ute->index=0;
+    ute->count=Transliterator::countAvailableIDs();
+    return (UEnumeration *)ute;

 }
 
 /********************************************************************
 }
 
 /********************************************************************


@@ -350,7 +398,7 @@ utrans_getAvailableID(int32_t index,
 U_CAPI void U_EXPORT2
 utrans_trans(const UTransliterator* trans,
              UReplaceable* rep,
 U_CAPI void U_EXPORT2
 utrans_trans(const UTransliterator* trans,
              UReplaceable* rep,

-             UReplaceableCallbacks* repFunc,
+             const UReplaceableCallbacks* repFunc,

              int32_t start,
              int32_t* limit,
              UErrorCode* status) {
              int32_t start,
              int32_t* limit,
              UErrorCode* status) {


@@ -370,7 +418,7 @@ utrans_trans(const UTransliterator* trans,
 U_CAPI void U_EXPORT2
 utrans_transIncremental(const UTransliterator* trans,
                         UReplaceable* rep,
 U_CAPI void U_EXPORT2
 utrans_transIncremental(const UTransliterator* trans,
                         UReplaceable* rep,

-                        UReplaceableCallbacks* repFunc,
+                        const UReplaceableCallbacks* repFunc,

                         UTransPosition* pos,
                         UErrorCode* status) {
 
                         UTransPosition* pos,
                         UErrorCode* status) {
 


@@ -447,4 +495,39 @@ utrans_transIncrementalUChars(const UTransliterator* trans,
     }
 }
 
     }
 }
 

+U_CAPI int32_t U_EXPORT2
+utrans_toRules(     const UTransliterator* trans,
+                    UBool escapeUnprintable,
+                    UChar* result, int32_t resultLength,
+                    UErrorCode* status) {
+    utrans_ENTRY(status) 0;
+    if ( (result==NULL)? resultLength!=0: resultLength<0 ) {
+        *status = U_ILLEGAL_ARGUMENT_ERROR;
+        return 0;
+    }
+
+    UnicodeString res;
+    res.setTo(result, 0, resultLength);
+    ((Transliterator*) trans)->toRules(res, escapeUnprintable);
+    return res.extract(result, resultLength, *status);
+}
+
+U_CAPI USet* U_EXPORT2
+utrans_getSourceSet(const UTransliterator* trans,
+                    UBool ignoreFilter,
+                    USet* fillIn,
+                    UErrorCode* status) {
+    utrans_ENTRY(status) fillIn;
+
+    if (fillIn == NULL) {
+        fillIn = uset_openEmpty();
+    }
+    if (ignoreFilter) {
+        ((Transliterator*) trans)->handleGetSourceSet(*((UnicodeSet*)fillIn));
+    } else {
+        ((Transliterator*) trans)->getSourceSet(*((UnicodeSet*)fillIn));
+    }
+    return fillIn;
+}
+

 #endif /* #if !UCONFIG_NO_TRANSLITERATION */
 #endif /* #if !UCONFIG_NO_TRANSLITERATION */