i18npool/source/characterclassification/characterclassificationImpl.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <cppuhelper/supportsservice.hxx>
  21 #include <characterclassificationImpl.hxx>
  22 #include <localedata.hxx>
  23
  24 #include <com/sun/star/uno/XComponentContext.hpp>
  25
  26 using namespace com::sun::star::uno;
  27 using namespace ::com::sun::star::i18n;
  28 using namespace com::sun::star::lang;
  29
  30 namespace i18npool {
  31
  32 CharacterClassificationImpl::CharacterClassificationImpl(
  33         const Reference < XComponentContext >& rxContext ) : m_xContext( rxContext )
  34 {
  35     if (createLocaleSpecificCharacterClassification(u"Unicode"_ustr, Locale()))
  36         xUCI = cachedItem->xCI;
  37 }
  38
  39 CharacterClassificationImpl::~CharacterClassificationImpl() {
  40 }
  41
  42
  43 OUString SAL_CALL
  44 CharacterClassificationImpl::toUpper( const OUString& Text, sal_Int32 nPos,
  45         sal_Int32 nCount, const Locale& rLocale )
  46 {
  47     return getLocaleSpecificCharacterClassification(rLocale)->toUpper(Text, nPos, nCount, rLocale);
  48 }
  49
  50 OUString SAL_CALL
  51 CharacterClassificationImpl::toLower( const OUString& Text, sal_Int32 nPos,
  52         sal_Int32 nCount, const Locale& rLocale )
  53 {
  54     return getLocaleSpecificCharacterClassification(rLocale)->toLower(Text, nPos, nCount, rLocale);
  55 }
  56
  57 OUString SAL_CALL
  58 CharacterClassificationImpl::toTitle( const OUString& Text, sal_Int32 nPos,
  59         sal_Int32 nCount, const Locale& rLocale )
  60 {
  61     return getLocaleSpecificCharacterClassification(rLocale)->toTitle(Text, nPos, nCount, rLocale);
  62 }
  63
  64 sal_Int16 SAL_CALL
  65 CharacterClassificationImpl::getType( const OUString& Text, sal_Int32 nPos )
  66 {
  67     if (xUCI.is())
  68         return xUCI->getType(Text, nPos);
  69     throw RuntimeException();
  70 }
  71
  72 sal_Int16 SAL_CALL
  73 CharacterClassificationImpl::getCharacterDirection( const OUString& Text, sal_Int32 nPos )
  74 {
  75     if (xUCI.is())
  76         return xUCI->getCharacterDirection(Text, nPos);
  77     throw RuntimeException();
  78 }
  79
  80 sal_Int16 SAL_CALL
  81 CharacterClassificationImpl::getScript( const OUString& Text, sal_Int32 nPos )
  82 {
  83     if (xUCI.is())
  84         return xUCI->getScript(Text, nPos);
  85     throw RuntimeException();
  86 }
  87
  88 sal_Int32 SAL_CALL
  89 CharacterClassificationImpl::getCharacterType( const OUString& Text, sal_Int32 nPos,
  90         const Locale& rLocale )
  91 {
  92     return getLocaleSpecificCharacterClassification(rLocale)->getCharacterType(Text, nPos, rLocale);
  93 }
  94
  95 sal_Int32 SAL_CALL
  96 CharacterClassificationImpl::getStringType( const OUString& Text, sal_Int32 nPos,
  97         sal_Int32 nCount, const Locale& rLocale )
  98 {
  99     return getLocaleSpecificCharacterClassification(rLocale)->getStringType(Text, nPos, nCount, rLocale);
 100 }
 101
 102 ParseResult SAL_CALL CharacterClassificationImpl::parseAnyToken(
 103         const OUString& Text, sal_Int32 nPos, const Locale& rLocale,
 104         sal_Int32 startCharTokenType, const OUString& userDefinedCharactersStart,
 105         sal_Int32 contCharTokenType, const OUString& userDefinedCharactersCont )
 106 {
 107     return getLocaleSpecificCharacterClassification(rLocale)->parseAnyToken(Text, nPos, rLocale,
 108             startCharTokenType,userDefinedCharactersStart,
 109             contCharTokenType, userDefinedCharactersCont);
 110 }
 111
 112
 113 ParseResult SAL_CALL CharacterClassificationImpl::parsePredefinedToken(
 114         sal_Int32 nTokenType, const OUString& Text, sal_Int32 nPos,
 115         const Locale& rLocale, sal_Int32 startCharTokenType,
 116         const OUString& userDefinedCharactersStart, sal_Int32 contCharTokenType,
 117         const OUString& userDefinedCharactersCont )
 118 {
 119     return getLocaleSpecificCharacterClassification(rLocale)->parsePredefinedToken(
 120             nTokenType, Text, nPos, rLocale, startCharTokenType, userDefinedCharactersStart,
 121             contCharTokenType, userDefinedCharactersCont);
 122 }
 123
 124 bool CharacterClassificationImpl::createLocaleSpecificCharacterClassification(const OUString& serviceName, const Locale& rLocale)
 125 {
 126     // to share service between same Language but different Country code, like zh_CN and zh_SG
 127     for (size_t l = 0; l < lookupTable.size(); l++) {
 128         cachedItem = lookupTable[l];
 129         if (serviceName == cachedItem->aName) {
 130             lookupTable.emplace_back( rLocale, serviceName, cachedItem->xCI );
 131             cachedItem = lookupTable.back();
 132             return true;
 133         }
 134     }
 135
 136     Reference < XInterface > xI = m_xContext->getServiceManager()->createInstanceWithContext(
 137             "com.sun.star.i18n.CharacterClassification_" + serviceName, m_xContext);
 138
 139     Reference < XCharacterClassification > xCI;
 140     if ( xI.is() ) {
 141         xCI.set( xI, UNO_QUERY );
 142         if (xCI.is()) {
 143             lookupTable.emplace_back( rLocale, serviceName, xCI );
 144             cachedItem = lookupTable.back();
 145             return true;
 146         }
 147     }
 148     return false;
 149 }
 150
 151 Reference < XCharacterClassification > const &
 152 CharacterClassificationImpl::getLocaleSpecificCharacterClassification(const Locale& rLocale)
 153 {
 154     // reuse instance if locale didn't change
 155     if (cachedItem && cachedItem->equals(rLocale))
 156         return cachedItem->xCI;
 157     else {
 158         for (const auto & i : lookupTable) {
 159             cachedItem = i;
 160             if (cachedItem->equals(rLocale))
 161                 return cachedItem->xCI;
 162         }
 163
 164         // Load service with name <base>_<lang>_<country> or
 165         // <base>_<bcp47> and fallbacks.
 166         bool bLoaded = createLocaleSpecificCharacterClassification(
 167                 LocaleDataImpl::getFirstLocaleServiceName( rLocale), rLocale);
 168         if (!bLoaded)
 169         {
 170             ::std::vector< OUString > aFallbacks( LocaleDataImpl::getFallbackLocaleServiceNames( rLocale));
 171             for (const auto& rFallback : aFallbacks)
 172             {
 173                 bLoaded = createLocaleSpecificCharacterClassification(rFallback, rLocale);
 174                 if (bLoaded)
 175                     break;
 176             }
 177         }
 178         if (bLoaded)
 179             return cachedItem->xCI;
 180         else if (xUCI.is())
 181         {
 182             lookupTable.emplace_back( rLocale, "Unicode", xUCI );
 183             cachedItem = lookupTable.back();
 184             return cachedItem->xCI;
 185         }
 186     }
 187     throw RuntimeException();
 188 }
 189
 190 OUString SAL_CALL
 191 CharacterClassificationImpl::getImplementationName()
 192 {
 193     return u"com.sun.star.i18n.CharacterClassification"_ustr;
 194 }
 195
 196 sal_Bool SAL_CALL
 197 CharacterClassificationImpl::supportsService(const OUString& rServiceName)
 198 {
 199     return cppu::supportsService(this, rServiceName);
 200 }
 201
 202 Sequence< OUString > SAL_CALL
 203 CharacterClassificationImpl::getSupportedServiceNames()
 204 {
 205     return { u"com.sun.star.i18n.CharacterClassification"_ustr };
 206 }
 207
 208 }
 209
 210 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
 211 com_sun_star_i18n_CharacterClassification_get_implementation(
 212     css::uno::XComponentContext *context,
 213     css::uno::Sequence<css::uno::Any> const &)
 214 {
 215     return cppu::acquire(new i18npool::CharacterClassificationImpl(context));
 216 }
 217
 218 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */