configmgr/source/xml/matchlocale.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: matchlocale.cxx,v $
  10  * $Revision: 1.12 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_configmgr.hxx"
  33 #include "matchlocale.hxx"
  34
  35 #include <rtl/ustrbuf.hxx>
  36
  37 #include <algorithm>
  38 #include <iterator>
  39
  40 namespace configmgr
  41 {
  42 // -----------------------------------------------------------------------------
  43     namespace localehelper
  44     {
  45 // -----------------------------------------------------------------------------
  46         namespace uno           = ::com::sun::star::uno;
  47         namespace lang          = ::com::sun::star::lang;
  48
  49 #define ARRAYSIZE( arr ) (sizeof(arr) / sizeof 0[arr] )
  50 // -----------------------------------------------------------------------------
  51     struct StaticLocale
  52     {
  53         char const * aLanguage;
  54         char const * aCountry;
  55     };
  56
  57     char const * const c_sAnyLanguage = "*";            // exported !
  58     char const * const c_sDefLanguage = "x-default";    // exported !
  59
  60     char const * const c_sNoCountry = "";
  61
  62     char const * const c_sLanguageEnglish = "en";
  63     char const * const c_sCountryUS = "US";
  64
  65     StaticLocale const c_aFallbackLocales[] =
  66     {
  67         { c_sLanguageEnglish,   c_sCountryUS }, // english [cannot make 'en' better than 'en-US' :-(]
  68         { c_sAnyLanguage,               c_sNoCountry }  // just take the first you find
  69     };
  70     std::vector< com::sun::star::lang::Locale >::size_type const c_nFallbackLocales = ARRAYSIZE(c_aFallbackLocales);
  71
  72 // -----------------------------------------------------------------------------
  73     bool isAnyLanguage(rtl::OUString const & _sLanguage)
  74     {
  75         return !!_sLanguage.equalsAscii(c_sAnyLanguage);
  76     }
  77
  78 // -----------------------------------------------------------------------------
  79     bool isDefaultLanguage(rtl::OUString const & _sLanguage)
  80     {
  81         return !!_sLanguage.equalsAscii(c_sDefLanguage);
  82     }
  83
  84 // -----------------------------------------------------------------------------
  85     rtl::OUString getAnyLanguage()
  86     {
  87         return rtl::OUString::createFromAscii( c_sAnyLanguage );
  88     }
  89
  90 // -----------------------------------------------------------------------------
  91     rtl::OUString getDefaultLanguage()
  92     {
  93         return rtl::OUString::createFromAscii( c_sDefLanguage );
  94     }
  95
  96 // -----------------------------------------------------------------------------
  97     com::sun::star::lang::Locale getAnyLocale()
  98     {
  99         return com::sun::star::lang::Locale( getAnyLanguage(), rtl::OUString(), rtl::OUString() );
 100     }
 101
 102 // -----------------------------------------------------------------------------
 103     com::sun::star::lang::Locale getDefaultLocale()
 104     {
 105         return com::sun::star::lang::Locale( getDefaultLanguage(), rtl::OUString(), rtl::OUString() );
 106     }
 107
 108 // -----------------------------------------------------------------------------
 109     static inline sal_Int32 countrySeparatorPos(rtl::OUString const& aLocaleName_)
 110     {
 111         sal_Int32 pos = aLocaleName_.indexOf('-');
 112         if (pos == 1) // allow for x-LL or i-LL
 113             pos = aLocaleName_.indexOf('-',pos+1);
 114
 115         if (pos < 0)
 116             pos = aLocaleName_.indexOf('_');
 117
 118         return pos;
 119     }
 120     // -------------------------------------------------------------------------
 121     static inline sal_Int32 countryLength(rtl::OUString const& aLocaleName_, sal_Int32 nCountryPos)
 122     {
 123         sal_Int32 pos1 = aLocaleName_.indexOf('.',nCountryPos);
 124         sal_Int32 pos2 = aLocaleName_.indexOf('_',nCountryPos);
 125
 126         if (pos1 < 0) pos1 = aLocaleName_.getLength();
 127
 128         if (pos2 < 0 || pos1 < pos2)
 129             return pos1 - nCountryPos;
 130
 131         else
 132             return pos2 - nCountryPos;
 133     }
 134     // -------------------------------------------------------------------------
 135     static inline void splitLocaleString(rtl::OUString const& aLocaleName_, rtl::OUString& rLanguage_, rtl::OUString& rCountry_)
 136     {
 137         sal_Int32 nCountryPos = countrySeparatorPos(aLocaleName_);
 138         if (nCountryPos >= 0)
 139         {
 140             rLanguage_ = aLocaleName_.copy(0,nCountryPos).toAsciiLowerCase();
 141
 142             ++nCountryPos; // advance past separator
 143             sal_Int32 nCountryLength = countryLength(aLocaleName_, nCountryPos);
 144
 145             rCountry_  = aLocaleName_.copy(nCountryPos,nCountryLength).toAsciiUpperCase();
 146         }
 147         else
 148         {
 149             rLanguage_ = aLocaleName_.toAsciiLowerCase();
 150             rCountry_  = rtl::OUString();
 151         }
 152     }
 153 // -----------------------------------------------------------------------------
 154
 155 // -----------------------------------------------------------------------------
 156 // conversion helpers
 157 com::sun::star::lang::Locale makeLocale(rtl::OUString const& sLocaleName_)
 158 {
 159     com::sun::star::lang::Locale aResult;
 160     splitLocaleString(sLocaleName_, aResult.Language, aResult.Country);
 161     return aResult;
 162 }
 163 rtl::OUString makeIsoLocale(com::sun::star::lang::Locale const& aUnoLocale_)
 164 {
 165     rtl::OUStringBuffer aResult(aUnoLocale_.Language.toAsciiLowerCase());
 166     if (aUnoLocale_.Country.getLength())
 167     {
 168         aResult.append( sal_Unicode('-') ).append(aUnoLocale_.Country.toAsciiUpperCase());
 169     }
 170     return aResult.makeStringAndClear();
 171 }
 172 static
 173 com::sun::star::lang::Locale makeLocale(StaticLocale const& aConstLocale_)
 174 {
 175     com::sun::star::lang::Locale aResult;
 176     aResult.Language = rtl::OUString::createFromAscii(aConstLocale_.aLanguage);
 177     aResult.Country  = rtl::OUString::createFromAscii(aConstLocale_.aCountry);
 178     return aResult;
 179 }
 180 // -----------------------------------------------------------------------------
 181 template <class T>
 182 inline
 183 void addLocaleSeq_impl(T const* first, T const* last, std::vector< com::sun::star::lang::Locale >& rSeq)
 184 {
 185     com::sun::star::lang::Locale (* const xlate)(T const&) = &makeLocale;
 186
 187     std::transform(first, last, std::back_inserter(rSeq), xlate);
 188 }
 189 // -----------------------------------------------------------------------------
 190 // -----------------------------------------------------------------------------
 191 template <class T>
 192 inline
 193 std::vector< com::sun::star::lang::Locale > makeLocaleSeq_impl(uno::Sequence< T > const& aLocales_)
 194 {
 195     sal_Int32 const nLocaleCount = aLocales_.getLength();
 196
 197     T const* pLocaleBegin = aLocales_.getConstArray();
 198
 199     std::vector< com::sun::star::lang::Locale > aResult;
 200     aResult.reserve( nLocaleCount + c_nFallbackLocales ); // make room for fallback stuff as well
 201
 202     addLocaleSeq_impl(pLocaleBegin, pLocaleBegin + nLocaleCount, aResult);
 203
 204     return aResult;
 205 }
 206 // -----------------------------------------------------------------------------
 207
 208 void addFallbackLocales(std::vector< com::sun::star::lang::Locale >& aTargetList_)
 209 {
 210     addLocaleSeq_impl(c_aFallbackLocales, c_aFallbackLocales + c_nFallbackLocales, aTargetList_);
 211 }
 212 // -----------------------------------------------------------------------------
 213
 214 std::vector< com::sun::star::lang::Locale > makeLocaleSequence(uno::Sequence<rtl::OUString> const& sLocaleNames_)
 215 {
 216     return makeLocaleSeq_impl(sLocaleNames_);
 217 }
 218 // -----------------------------------------------------------------------------
 219
 220 uno::Sequence<rtl::OUString> makeIsoSequence(std::vector< com::sun::star::lang::Locale > const& aLocales_)
 221 {
 222     std::vector< com::sun::star::lang::Locale >::size_type const nLocaleCount = aLocales_.size();
 223     sal_Int32 const nSeqSize = sal_Int32(nLocaleCount);
 224     OSL_ASSERT( nSeqSize >= 0 && sal_uInt32(nSeqSize) == nLocaleCount );
 225
 226     uno::Sequence<rtl::OUString> aResult(nSeqSize);
 227     std::transform(aLocales_.begin(), aLocales_.end(), aResult.getArray(), &makeIsoLocale);
 228
 229     return aResult;
 230 }
 231 // -----------------------------------------------------------------------------
 232 bool designatesAllLocales(com::sun::star::lang::Locale const& aLocale_)
 233 {
 234     return aLocale_.Language.equalsAscii(c_sAnyLanguage);
 235 }
 236 bool designatesAllLocales(std::vector< com::sun::star::lang::Locale > const& aLocales_)
 237 {
 238     return      aLocales_.size() <= 1 &&
 239             (aLocales_.size() == 0 || designatesAllLocales(aLocales_));
 240 }
 241 // -----------------------------------------------------------------------------
 242
 243 MatchQuality match(com::sun::star::lang::Locale const& aLocale_, com::sun::star::lang::Locale const& aTarget_)
 244 {
 245     // check language
 246     if (!aLocale_.Language.equals(aTarget_.Language))
 247     {
 248         // can we accept any language
 249         if (aTarget_.Language.equalsAscii(c_sAnyLanguage))
 250             return MATCH_LANGUAGE;
 251
 252         return MISMATCH;
 253     }
 254
 255     // check for exact match
 256     else if (aLocale_.Country.equals(aTarget_.Country))
 257         return MATCH_LOCALE;
 258
 259     // check for plain language
 260     else if (aLocale_.Country.getLength() == 0)
 261         return MATCH_LANGUAGE_PLAIN;
 262
 263     // so we are left with the wrong country
 264     else
 265         return MATCH_LANGUAGE;
 266 }
 267
 268 // -----------------------------------------------------------------------------
 269
 270 /// check the given position and quality, if they are an improvement
 271 bool MatchResult::improve(std::vector< com::sun::star::lang::Locale >::size_type nPos_, MatchQuality eQuality_)
 272 {
 273     // is this a match at all ?
 274     if (eQuality_ == MISMATCH)
 275         return false;
 276
 277     // is the position worse ?
 278     if (nPos_ > m_nPos )
 279         return false;
 280
 281     // is this just a non-positive quality change ?
 282     if (nPos_ == m_nPos && eQuality_ <= m_eQuality)
 283         return false;
 284
 285     // Improvement found
 286     m_nPos              = nPos_;
 287     m_eQuality  = eQuality_;
 288
 289     return true;
 290 }
 291
 292 // -----------------------------------------------------------------------------
 293
 294 bool isMatch(com::sun::star::lang::Locale const& aLocale_, std::vector< com::sun::star::lang::Locale > const& aTarget_, MatchQuality eRequiredQuality_)
 295 {
 296     std::vector< com::sun::star::lang::Locale >::size_type const nEnd = aTarget_.size();
 297
 298     for (std::vector< com::sun::star::lang::Locale >::size_type nPos = 0; nPos < nEnd; ++nPos)
 299     {
 300         MatchQuality eQuality = match(aLocale_, aTarget_[nPos]);
 301         if (eQuality >= eRequiredQuality_)
 302         {
 303             return true;
 304         }
 305     }
 306     return false;
 307 }
 308 // -----------------------------------------------------------------------------
 309
 310 static
 311 inline
 312 std::vector< com::sun::star::lang::Locale >::size_type getSearchLimitPosition(MatchResult const& aPrevMatch_,std::vector< com::sun::star::lang::Locale > const& aTarget_)
 313 {
 314     std::vector< com::sun::star::lang::Locale >::size_type nSize = aTarget_.size();
 315
 316     if (aPrevMatch_.isMatch())
 317     {
 318         std::vector< com::sun::star::lang::Locale >::size_type nMatchPos = aPrevMatch_.position();
 319
 320         OSL_ENSURE(nMatchPos < nSize,"localehelper::getSearchLimitPosition: ERROR - previous position is out-of-bounds");
 321
 322         if (nMatchPos < nSize)
 323         {
 324             return nMatchPos + 1;
 325         }
 326     }
 327     return nSize;
 328 }
 329 // -----------------------------------------------------------------------------
 330
 331 bool improveMatch(MatchResult& rMatch_, com::sun::star::lang::Locale const& aLocale_, std::vector< com::sun::star::lang::Locale > const& aTarget_)
 332 {
 333     std::vector< com::sun::star::lang::Locale >::size_type const nEnd = getSearchLimitPosition(rMatch_,aTarget_);
 334
 335     for (std::vector< com::sun::star::lang::Locale >::size_type nPos = 0; nPos < nEnd; ++nPos)
 336     {
 337         if (rMatch_.improve(nPos, match(aLocale_, aTarget_[nPos])))
 338         {
 339             return true;
 340         }
 341     }
 342     return false;
 343 }
 344 // -----------------------------------------------------------------------------
 345
 346
 347 // -----------------------------------------------------------------------------
 348 // class FindBestLocale
 349 // -----------------------------------------------------------------------------
 350
 351 inline
 352 void FindBestLocale::implSetTarget(std::vector< com::sun::star::lang::Locale > const& aTarget_)
 353 {
 354     m_aTarget = aTarget_;
 355     addFallbackLocales(m_aTarget);
 356 }
 357 // -----------------------------------------------------------------------------
 358
 359 FindBestLocale::FindBestLocale(com::sun::star::lang::Locale const& aTarget_)
 360 {
 361     std::vector< com::sun::star::lang::Locale > aSeq(1,aTarget_);
 362     implSetTarget( aSeq );
 363 }
 364 // -----------------------------------------------------------------------------
 365
 366 bool FindBestLocale::accept(com::sun::star::lang::Locale const& aLocale_)
 367 {
 368     return improveMatch(m_aResult, aLocale_, m_aTarget);
 369 }
 370 // -----------------------------------------------------------------------------
 371
 372 void FindBestLocale::reset(bool bNeedLocale_)
 373 {
 374     if (bNeedLocale_)
 375         m_aResult.reset();
 376
 377     else // mark as best match already (no improvement possible)
 378         m_aResult = m_aResult.best();
 379 }
 380 // -----------------------------------------------------------------------------
 381
 382     } // namespace locale helper
 383 // -----------------------------------------------------------------------------
 384
 385 } // namespace
 386
 387