linguistic/source/thesdsp.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 <i18nlangtag/lang.h>
  21 #include <i18nlangtag/languagetag.hxx>
  22 #include <tools/debug.hxx>
  23 #include <svl/lngmisc.hxx>
  24
  25 #include <com/sun/star/beans/XPropertySet.hpp>
  26 #include <comphelper/processfactory.hxx>
  27 #include <comphelper/sequence.hxx>
  28 #include <com/sun/star/uno/XComponentContext.hpp>
  29 #include <osl/mutex.hxx>
  30 #include <sal/log.hxx>
  31
  32 #include "thesdsp.hxx"
  33 #include <linguistic/misc.hxx>
  34
  35 using namespace osl;
  36 using namespace com::sun::star;
  37 using namespace com::sun::star::beans;
  38 using namespace com::sun::star::lang;
  39 using namespace com::sun::star::uno;
  40 using namespace com::sun::star::linguistic2;
  41 using namespace linguistic;
  42
  43
  44 static bool SvcListHasLanguage(
  45         const Sequence< Reference< XThesaurus > > &rRefs,
  46         const Locale &rLocale )
  47 {
  48     return std::any_of(rRefs.begin(), rRefs.end(),
  49         [&rLocale](const Reference<XThesaurus>& rRef) {
  50             return rRef.is() && rRef->hasLocale( rLocale ); });
  51 }
  52
  53
  54 ThesaurusDispatcher::ThesaurusDispatcher()
  55 {
  56 }
  57
  58
  59 ThesaurusDispatcher::~ThesaurusDispatcher()
  60 {
  61     ClearSvcList();
  62 }
  63
  64
  65 void ThesaurusDispatcher::ClearSvcList()
  66 {
  67     // release memory for each table entry
  68     ThesSvcByLangMap_t aTmp;
  69     aSvcMap.swap( aTmp );
  70 }
  71
  72
  73 Sequence< Locale > SAL_CALL
  74     ThesaurusDispatcher::getLocales()
  75 {
  76     MutexGuard  aGuard( GetLinguMutex() );
  77
  78     std::vector<Locale> aLocales;
  79     aLocales.reserve(aSvcMap.size());
  80
  81     std::transform(aSvcMap.begin(), aSvcMap.end(), std::back_inserter(aLocales),
  82         [](ThesSvcByLangMap_t::const_reference elem) { return LanguageTag::convertToLocale(elem.first); });
  83
  84     return comphelper::containerToSequence(aLocales);
  85 }
  86
  87
  88 sal_Bool SAL_CALL
  89     ThesaurusDispatcher::hasLocale( const Locale& rLocale )
  90 {
  91     MutexGuard  aGuard( GetLinguMutex() );
  92     ThesSvcByLangMap_t::const_iterator aIt( aSvcMap.find( LinguLocaleToLanguage( rLocale ) ) );
  93     return aIt != aSvcMap.end();
  94 }
  95
  96
  97 Sequence< Reference< XMeaning > > SAL_CALL
  98     ThesaurusDispatcher::queryMeanings(
  99             const OUString& rTerm, const Locale& rLocale,
 100             const css::uno::Sequence< ::css::beans::PropertyValue >& rProperties )
 101 {
 102     MutexGuard  aGuard( GetLinguMutex() );
 103
 104     Sequence< Reference< XMeaning > >   aMeanings;
 105
 106     LanguageType nLanguage = LinguLocaleToLanguage( rLocale );
 107     if (LinguIsUnspecified( nLanguage) || rTerm.isEmpty())
 108         return aMeanings;
 109
 110     // search for entry with that language
 111     ThesSvcByLangMap_t::iterator    aIt( aSvcMap.find( nLanguage ) );
 112     LangSvcEntries_Thes     *pEntry = aIt != aSvcMap.end() ? aIt->second.get() : nullptr;
 113
 114     if (pEntry)
 115     {
 116         OUString aChkWord = rTerm.replace( SVT_HARD_SPACE, ' ' );
 117         RemoveHyphens( aChkWord );
 118         if (IsIgnoreControlChars( rProperties, GetPropSet() ))
 119             RemoveControlChars( aChkWord );
 120
 121         sal_Int32 nLen = pEntry->aSvcRefs.getLength();
 122         DBG_ASSERT( nLen == pEntry->aSvcImplNames.getLength(),
 123                 "lng : sequence length mismatch");
 124         DBG_ASSERT( pEntry->nLastTriedSvcIndex < nLen,
 125                 "lng : index out of range");
 126
 127         sal_Int32 i = 0;
 128
 129         // try already instantiated services first
 130         {
 131             const Reference< XThesaurus > *pRef = pEntry->aSvcRefs.getConstArray();
 132             while (i <= pEntry->nLastTriedSvcIndex
 133                    &&  !aMeanings.hasElements())
 134             {
 135                 if (pRef[i].is()  &&  pRef[i]->hasLocale( rLocale ))
 136                     aMeanings = pRef[i]->queryMeanings( aChkWord, rLocale, rProperties );
 137                 ++i;
 138             }
 139         }
 140
 141         // if still no result instantiate new services and try those
 142         if (!aMeanings.hasElements()
 143             &&  pEntry->nLastTriedSvcIndex < nLen - 1)
 144         {
 145             const OUString *pImplNames = pEntry->aSvcImplNames.getConstArray();
 146             Reference< XThesaurus > *pRef = pEntry->aSvcRefs.getArray();
 147
 148             Reference< XComponentContext > xContext(
 149                 comphelper::getProcessComponentContext() );
 150
 151             // build service initialization argument
 152             Sequence< Any > aArgs(1);
 153             aArgs.getArray()[0] <<= GetPropSet();
 154
 155             while (i < nLen  &&  !aMeanings.hasElements())
 156             {
 157                 // create specific service via it's implementation name
 158                 Reference< XThesaurus > xThes;
 159                 try
 160                 {
 161                     xThes.set(  xContext->getServiceManager()->createInstanceWithArgumentsAndContext(
 162                                     pImplNames[i], aArgs, xContext ),
 163                                 UNO_QUERY );
 164                 }
 165                 catch (uno::Exception &)
 166                 {
 167                     SAL_WARN( "linguistic", "createInstanceWithArguments failed" );
 168                 }
 169                 pRef[i] = xThes;
 170
 171                 if (xThes.is()  &&  xThes->hasLocale( rLocale ))
 172                     aMeanings = xThes->queryMeanings( aChkWord, rLocale, rProperties );
 173
 174                 pEntry->nLastTriedSvcIndex = static_cast<sal_Int16>(i);
 175                 ++i;
 176             }
 177
 178             // if language is not supported by any of the services
 179             // remove it from the list.
 180             if (i == nLen  &&  !aMeanings.hasElements())
 181             {
 182                 if (!SvcListHasLanguage( pEntry->aSvcRefs, rLocale ))
 183                     aSvcMap.erase( nLanguage );
 184             }
 185         }
 186     }
 187
 188     return aMeanings;
 189 }
 190
 191
 192 void ThesaurusDispatcher::SetServiceList( const Locale &rLocale,
 193         const Sequence< OUString > &rSvcImplNames )
 194 {
 195     MutexGuard  aGuard( GetLinguMutex() );
 196
 197     LanguageType nLanguage = LinguLocaleToLanguage( rLocale );
 198
 199     sal_Int32 nLen = rSvcImplNames.getLength();
 200     if (0 == nLen)
 201         // remove entry
 202         aSvcMap.erase( nLanguage );
 203     else
 204     {
 205         // modify/add entry
 206         LangSvcEntries_Thes *pEntry = aSvcMap[ nLanguage ].get();
 207         if (pEntry)
 208         {
 209             pEntry->Clear();
 210             pEntry->aSvcImplNames = rSvcImplNames;
 211             pEntry->aSvcRefs = Sequence< Reference < XThesaurus > >( nLen );
 212         }
 213         else
 214         {
 215             std::shared_ptr< LangSvcEntries_Thes > pTmpEntry( new LangSvcEntries_Thes( rSvcImplNames ) );
 216             pTmpEntry->aSvcRefs = Sequence< Reference < XThesaurus > >( nLen );
 217             aSvcMap[ nLanguage ] = pTmpEntry;
 218         }
 219     }
 220 }
 221
 222
 223 Sequence< OUString >
 224     ThesaurusDispatcher::GetServiceList( const Locale &rLocale ) const
 225 {
 226     MutexGuard  aGuard( GetLinguMutex() );
 227
 228     Sequence< OUString > aRes;
 229
 230     // search for entry with that language and use data from that
 231     LanguageType nLanguage = LinguLocaleToLanguage( rLocale );
 232     const ThesSvcByLangMap_t::const_iterator  aIt( aSvcMap.find( nLanguage ) );
 233     const LangSvcEntries_Thes       *pEntry = aIt != aSvcMap.end() ? aIt->second.get() : nullptr;
 234     if (pEntry)
 235         aRes = pEntry->aSvcImplNames;
 236
 237     return aRes;
 238 }
 239
 240
 241 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */