typesafe wrappers for css::i18nutil::TransliterationModules

and related css::util::SearchOptions2

The TransliterationModules enum has it's constants spread over multiple
UNO enum/constant-collections - TransliterationModules and
TransliterationModulesExtra, which means that most code simply uses
sal_Int32.

Wrap them up into a better bundle so that only the lowest layer needs to
deal directly with the UNO constants.

Change-Id: I1edeab79fcc7817a4a97c933ef84ab7015bb849b
Reviewed-on: https://gerrit.libreoffice.org/34582
Reviewed-by: Noel Grandin <noel.grandin@collabora.co.uk>
Tested-by: Noel Grandin <noel.grandin@collabora.co.uk>

4 files changed, 55 insertions, 58 deletions

diff --git a/unotools/source/config/searchopt.cxx b/unotools/source/config/searchopt.cxx
index f6a0fbffe575..b4d570496ffb 100644
--- a/unotools/source/config/searchopt.cxx
+++ b/unotools/source/config/searchopt.cxx
@@ -22,16 +22,14 @@
 #include <unotools/searchopt.hxx>
 #include <tools/debug.hxx>
 #include <unotools/configitem.hxx>
-#include <com/sun/star/i18n/TransliterationModules.hpp>
-#include <com/sun/star/i18n/TransliterationModulesExtra.hpp>
 #include <com/sun/star/uno/Sequence.hxx>
 #include <com/sun/star/uno/Any.h>
 #include <sal/macros.h>
 #include <osl/diagnose.h>
+#include <i18nutil/transliteration.hxx>
 
 using namespace utl;
 using namespace com::sun::star::uno;
-using namespace com::sun::star::i18n;
 
 #define MAX_FLAGS_OFFSET    29
 
@@ -268,52 +266,52 @@ void SvtSearchOptions::Commit()
     pImpl->Commit();
 }
 
-sal_Int32 SvtSearchOptions::GetTransliterationFlags() const
+TransliterationFlags SvtSearchOptions::GetTransliterationFlags() const
 {
-    sal_Int32 nRes = 0;
+    TransliterationFlags nRes = TransliterationFlags::NONE;
 
     if (!IsMatchCase()) // 'IsMatchCase' means act case sensitive
-        nRes |= TransliterationModules_IGNORE_CASE;
+        nRes |= TransliterationFlags::IGNORE_CASE;
     if ( IsMatchFullHalfWidthForms())
-        nRes |= TransliterationModules_IGNORE_WIDTH;
+        nRes |= TransliterationFlags::IGNORE_WIDTH;
     if ( IsMatchHiraganaKatakana())
-        nRes |= TransliterationModules_IGNORE_KANA;
+        nRes |= TransliterationFlags::IGNORE_KANA;
     if ( IsMatchContractions())
-        nRes |= TransliterationModules_ignoreSize_ja_JP;
+        nRes |= TransliterationFlags::ignoreSize_ja_JP;
     if ( IsMatchMinusDashChoon())
-        nRes |= TransliterationModules_ignoreMinusSign_ja_JP;
+        nRes |= TransliterationFlags::ignoreMinusSign_ja_JP;
     if ( IsMatchRepeatCharMarks())
-        nRes |= TransliterationModules_ignoreIterationMark_ja_JP;
+        nRes |= TransliterationFlags::ignoreIterationMark_ja_JP;
     if ( IsMatchVariantFormKanji())
-        nRes |= TransliterationModules_ignoreTraditionalKanji_ja_JP;
+        nRes |= TransliterationFlags::ignoreTraditionalKanji_ja_JP;
     if ( IsMatchOldKanaForms())
-        nRes |= TransliterationModules_ignoreTraditionalKana_ja_JP;
+        nRes |= TransliterationFlags::ignoreTraditionalKana_ja_JP;
     if ( IsMatchDiziDuzu())
-        nRes |= TransliterationModules_ignoreZiZu_ja_JP;
+        nRes |= TransliterationFlags::ignoreZiZu_ja_JP;
     if ( IsMatchBavaHafa())
-        nRes |= TransliterationModules_ignoreBaFa_ja_JP;
+        nRes |= TransliterationFlags::ignoreBaFa_ja_JP;
     if ( IsMatchTsithichiDhizi())
-        nRes |= TransliterationModules_ignoreTiJi_ja_JP;
+        nRes |= TransliterationFlags::ignoreTiJi_ja_JP;
     if ( IsMatchHyuiyuByuvyu())
-        nRes |= TransliterationModules_ignoreHyuByu_ja_JP;
+        nRes |= TransliterationFlags::ignoreHyuByu_ja_JP;
     if ( IsMatchSesheZeje())
-        nRes |= TransliterationModules_ignoreSeZe_ja_JP;
+        nRes |= TransliterationFlags::ignoreSeZe_ja_JP;
     if ( IsMatchIaiya())
-        nRes |= TransliterationModules_ignoreIandEfollowedByYa_ja_JP;
+        nRes |= TransliterationFlags::ignoreIandEfollowedByYa_ja_JP;
     if ( IsMatchKiku())
-        nRes |= TransliterationModules_ignoreKiKuFollowedBySa_ja_JP;
+        nRes |= TransliterationFlags::ignoreKiKuFollowedBySa_ja_JP;
     if ( IsIgnorePunctuation())
-        nRes |= TransliterationModules_ignoreSeparator_ja_JP;
+        nRes |= TransliterationFlags::ignoreSeparator_ja_JP;
     if ( IsIgnoreWhitespace())
-        nRes |= TransliterationModules_ignoreSpace_ja_JP;
+        nRes |= TransliterationFlags::ignoreSpace_ja_JP;
     if ( IsIgnoreProlongedSoundMark())
-        nRes |= TransliterationModules_ignoreProlongedSoundMark_ja_JP;
+        nRes |= TransliterationFlags::ignoreProlongedSoundMark_ja_JP;
     if ( IsIgnoreMiddleDot())
-        nRes |= TransliterationModules_ignoreMiddleDot_ja_JP;
+        nRes |= TransliterationFlags::ignoreMiddleDot_ja_JP;
     if ( IsIgnoreDiacritics_CTL())
-        nRes |= TransliterationModulesExtra::IGNORE_DIACRITICS_CTL;
+        nRes |= TransliterationFlags::IGNORE_DIACRITICS_CTL;
     if ( IsIgnoreKashida_CTL())
-        nRes |= TransliterationModulesExtra::IGNORE_KASHIDA_CTL;
+        nRes |= TransliterationFlags::IGNORE_KASHIDA_CTL;
     return nRes;
 }
 
diff --git a/unotools/source/i18n/caserotate.cxx b/unotools/source/i18n/caserotate.cxx
index d69fe0c63ad7..d4921e9053ef 100644
--- a/unotools/source/i18n/caserotate.cxx
+++ b/unotools/source/i18n/caserotate.cxx
@@ -8,29 +8,26 @@
  */
 
 #include <unotools/caserotate.hxx>
-#include <com/sun/star/i18n/TransliterationModules.hpp>
-#include <com/sun/star/i18n/TransliterationModulesExtra.hpp>
+#include <i18nutil/transliteration.hxx>
 
 //TODO Use XCharacterClassification::getStringType to determine the current
 //(possibly mixed) case type and rotate to the next one
 
-sal_uInt32 RotateTransliteration::getNextMode()
+TransliterationFlags RotateTransliteration::getNextMode()
 {
-    using namespace ::com::sun::star::i18n;
-
-    sal_uInt32 nMode = 0;
+    TransliterationFlags nMode = TransliterationFlags::NONE;
 
     switch (nF3ShiftCounter)
     {
         case 0:
-            nMode = TransliterationModulesExtra::TITLE_CASE;
+            nMode = TransliterationFlags::TITLE_CASE;
             break;
         case 1:
-            nMode = TransliterationModules_LOWERCASE_UPPERCASE;
+            nMode = TransliterationFlags::LOWERCASE_UPPERCASE;
             break;
         default:
         case 2:
-            nMode = TransliterationModules_UPPERCASE_LOWERCASE;
+            nMode = TransliterationFlags::UPPERCASE_LOWERCASE;
             nF3ShiftCounter = -1;
             break;
     }
diff --git a/unotools/source/i18n/textsearch.cxx b/unotools/source/i18n/textsearch.cxx
index d147765ca507..98dc9846083b 100644
--- a/unotools/source/i18n/textsearch.cxx
+++ b/unotools/source/i18n/textsearch.cxx
@@ -22,11 +22,12 @@
 #include <cstdlib>
 
 #include <i18nlangtag/languagetag.hxx>
+#include <i18nutil/searchopt.hxx>
+#include <i18nutil/transliteration.hxx>
 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
 #include <com/sun/star/util/TextSearch2.hpp>
 #include <com/sun/star/util/SearchAlgorithms2.hpp>
 #include <com/sun/star/util/SearchFlags.hpp>
-#include <com/sun/star/i18n/TransliterationModules.hpp>
 #include <sal/log.hxx>
 #include <unotools/charclass.hxx>
 #include <comphelper/processfactory.hxx>
@@ -57,7 +58,7 @@ SearchParam::SearchParam( const OUString &rText,
     m_bCaseSense    = bCaseSensitive;
     m_bWildMatchSel = bWildMatchSel;
 
-    nTransliterationFlags = 0;
+    nTransliterationFlags = TransliterationFlags::NONE;
 
     // Parameters for weighted Levenshtein distance
     bLEV_Relaxed    = true;
@@ -89,7 +90,7 @@ SearchParam::SearchParam( const SearchParam& rParam )
 
 SearchParam::~SearchParam() {}
 
-static bool lcl_Equals( const SearchOptions2& rSO1, const SearchOptions2& rSO2 )
+static bool lcl_Equals( const i18nutil::SearchOptions2& rSO1, const i18nutil::SearchOptions2& rSO2 )
 {
     return
         rSO1.AlgorithmType2 == rSO2.AlgorithmType2 &&
@@ -112,7 +113,7 @@ namespace
     struct CachedTextSearch
     {
         ::osl::Mutex mutex;
-        css::util::SearchOptions2 Options;
+        i18nutil::SearchOptions2 Options;
         css::uno::Reference< css::util::XTextSearch2 > xTextSearch;
     };
 
@@ -120,7 +121,7 @@ namespace
         : public rtl::Static< CachedTextSearch, theCachedTextSearch > {};
 }
 
-Reference<XTextSearch2> TextSearch::getXTextSearch( const SearchOptions2& rPara )
+Reference<XTextSearch2> TextSearch::getXTextSearch( const i18nutil::SearchOptions2& rPara )
 {
     CachedTextSearch &rCache = theCachedTextSearch::get();
 
@@ -131,7 +132,7 @@ Reference<XTextSearch2> TextSearch::getXTextSearch( const SearchOptions2& rPara
 
     Reference< XComponentContext > xContext = ::comphelper::getProcessComponentContext();
     rCache.xTextSearch.set( ::TextSearch2::create(xContext) );
-    rCache.xTextSearch->setOptions2( rPara );
+    rCache.xTextSearch->setOptions2( rPara.toUnoSearchOptions2() );
     rCache.Options = rPara;
 
     return rCache.xTextSearch;
@@ -151,12 +152,12 @@ TextSearch::TextSearch(const SearchParam & rParam, const CharClass& rCClass )
     Init( rParam, rCClass.getLanguageTag().getLocale() );
 }
 
-TextSearch::TextSearch( const SearchOptions2& rPara )
+TextSearch::TextSearch( const i18nutil::SearchOptions2& rPara )
 {
     xTextSearch = getXTextSearch( rPara );
 }
 
-css::util::SearchOptions2 TextSearch::UpgradeToSearchOptions2( const css::util::SearchOptions& rOptions )
+i18nutil::SearchOptions2 TextSearch::UpgradeToSearchOptions2( const i18nutil::SearchOptions& rOptions )
 {
     sal_Int16 nAlgorithmType2;
     switch (rOptions.algorithmType)
@@ -175,7 +176,7 @@ css::util::SearchOptions2 TextSearch::UpgradeToSearchOptions2( const css::util::
     }
     // It would be nice if an inherited struct had a ctor that takes an
     // instance of the object the struct derived from..
-    SearchOptions2 aOptions2(
+    i18nutil::SearchOptions2 aOptions2(
             rOptions.algorithmType,
             rOptions.searchFlag,
             rOptions.searchString,
@@ -195,7 +196,7 @@ void TextSearch::Init( const SearchParam & rParam,
                         const css::lang::Locale& rLocale )
 {
     // convert SearchParam to the UNO SearchOptions2
-    SearchOptions2 aSOpt;
+    i18nutil::SearchOptions2 aSOpt;
 
     switch( rParam.GetSrchType() )
     {
@@ -232,16 +233,16 @@ void TextSearch::Init( const SearchParam & rParam,
     if( !rParam.IsCaseSensitive() )
     {
         aSOpt.searchFlag |= SearchFlags::ALL_IGNORE_CASE;
-        aSOpt.transliterateFlags |= css::i18n::TransliterationModules_IGNORE_CASE;
+        aSOpt.transliterateFlags |= TransliterationFlags::IGNORE_CASE;
     }
 
     xTextSearch = getXTextSearch( aSOpt );
 }
 
-void TextSearch::SetLocale( const css::util::SearchOptions2& rOptions,
+void TextSearch::SetLocale( const i18nutil::SearchOptions2& rOptions,
                             const css::lang::Locale& rLocale )
 {
-    SearchOptions2 aSOpt( rOptions );
+    i18nutil::SearchOptions2 aSOpt( rOptions );
     aSOpt.Locale = rLocale;
 
     xTextSearch = getXTextSearch( aSOpt );
diff --git a/unotools/source/i18n/transliterationwrapper.cxx b/unotools/source/i18n/transliterationwrapper.cxx
index 4e69bb9eaa02..6e0cd7b521b3 100644
--- a/unotools/source/i18n/transliterationwrapper.cxx
+++ b/unotools/source/i18n/transliterationwrapper.cxx
@@ -22,6 +22,7 @@
 #include <sal/log.hxx>
 #include <unotools/transliterationwrapper.hxx>
 #include <i18nlangtag/languagetag.hxx>
+#include <i18nutil/transliteration.hxx>
 
 #include <com/sun/star/i18n/TransliterationModulesExtra.hpp>
 #include <com/sun/star/i18n/Transliteration.hpp>
@@ -33,7 +34,7 @@ using namespace ::utl;
 
 TransliterationWrapper::TransliterationWrapper(
                     const Reference< XComponentContext > & rxContext,
-                    sal_uInt32 nTyp )
+                    TransliterationFlags nTyp )
     : xTrans( Transliteration::create(rxContext) ),
       aLanguageTag( LANGUAGE_SYSTEM ), nType( nTyp ), bFirstCall( true )
 {
@@ -87,12 +88,12 @@ OUString TransliterationWrapper::transliterate( const OUString& rStr,
 
 bool TransliterationWrapper::needLanguageForTheMode() const
 {
-    return TransliterationModules_UPPERCASE_LOWERCASE == nType ||
-           TransliterationModules_LOWERCASE_UPPERCASE == nType ||
-           TransliterationModules_IGNORE_CASE == nType ||
-           (sal_uInt32) TransliterationModulesExtra::SENTENCE_CASE == (sal_uInt32) nType ||
-           (sal_uInt32) TransliterationModulesExtra::TITLE_CASE    == (sal_uInt32) nType ||
-           (sal_uInt32) TransliterationModulesExtra::TOGGLE_CASE   == (sal_uInt32) nType;
+    return TransliterationFlags::UPPERCASE_LOWERCASE == nType ||
+           TransliterationFlags::LOWERCASE_UPPERCASE == nType ||
+           TransliterationFlags::IGNORE_CASE == nType ||
+           TransliterationFlags::SENTENCE_CASE == nType ||
+           TransliterationFlags::TITLE_CASE    == nType ||
+           TransliterationFlags::TOGGLE_CASE   == nType;
 }
 
 void TransliterationWrapper::setLanguageLocaleImpl( sal_uInt16 nLang )
@@ -107,17 +108,17 @@ void TransliterationWrapper::loadModuleIfNeeded( sal_uInt16 nLang )
     bool bLoad = bFirstCall;
     bFirstCall = false;
 
-    if( static_cast< sal_Int32 >(nType) == TransliterationModulesExtra::SENTENCE_CASE )
+    if( nType == TransliterationFlags::SENTENCE_CASE )
     {
         if( bLoad )
             loadModuleByImplName("SENTENCE_CASE", nLang);
     }
-    else if( static_cast< sal_Int32 >(nType) == TransliterationModulesExtra::TITLE_CASE )
+    else if( nType == TransliterationFlags::TITLE_CASE )
     {
         if( bLoad )
             loadModuleByImplName("TITLE_CASE", nLang);
     }
-    else if( static_cast< sal_Int32 >(nType) == TransliterationModulesExtra::TOGGLE_CASE )
+    else if( nType == TransliterationFlags::TOGGLE_CASE )
     {
         if( bLoad )
             loadModuleByImplName("TOGGLE_CASE", nLang);