i18npool/source/indexentry/indexentrysupplier_default.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 <indexentrysupplier_default.hxx>
  21 #include <localedata.hxx>
  22 #include <i18nutil/unicode.hxx>
  23 #include <com/sun/star/i18n/CollatorOptions.hpp>
  24
  25 using namespace ::com::sun::star::uno;
  26 using namespace ::com::sun::star::lang;
  27
  28 namespace com { namespace sun { namespace star { namespace i18n {
  29
  30 IndexEntrySupplier_Unicode::IndexEntrySupplier_Unicode(
  31     const css::uno::Reference < css::uno::XComponentContext >& rxContext ) :
  32     IndexEntrySupplier_Common(rxContext)
  33 {
  34     implementationName = "com.sun.star.i18n.IndexEntrySupplier_Unicode";
  35     index.reset( new Index(rxContext) );
  36 }
  37
  38 IndexEntrySupplier_Unicode::~IndexEntrySupplier_Unicode()
  39 {
  40 }
  41
  42 sal_Bool SAL_CALL IndexEntrySupplier_Unicode::loadAlgorithm( const lang::Locale& rLocale,
  43     const OUString& rAlgorithm, sal_Int32 collatorOptions )
  44 {
  45     index->init(rLocale, rAlgorithm);
  46     return IndexEntrySupplier_Common::loadAlgorithm(rLocale, rAlgorithm, collatorOptions);
  47 }
  48
  49 OUString SAL_CALL IndexEntrySupplier_Unicode::getIndexKey( const OUString& rIndexEntry,
  50     const OUString& rPhoneticEntry, const lang::Locale& rLocale )
  51 {
  52     return index->getIndexDescription(getEntry(rIndexEntry, rPhoneticEntry, rLocale));
  53 }
  54
  55 sal_Int16 SAL_CALL IndexEntrySupplier_Unicode::compareIndexEntry(
  56     const OUString& rIndexEntry1, const OUString& rPhoneticEntry1, const lang::Locale& rLocale1,
  57     const OUString& rIndexEntry2, const OUString& rPhoneticEntry2, const lang::Locale& rLocale2 )
  58 {
  59     sal_Int16 result =
  60             index->getIndexWeight(getEntry(rIndexEntry1, rPhoneticEntry1, rLocale1)) -
  61             index->getIndexWeight(getEntry(rIndexEntry2, rPhoneticEntry2, rLocale2));
  62     if (result == 0)
  63         return IndexEntrySupplier_Common::compareIndexEntry(
  64                     rIndexEntry1, rPhoneticEntry1, rLocale1,
  65                     rIndexEntry2, rPhoneticEntry2, rLocale2);
  66     return result > 0 ? 1 : -1;
  67 }
  68
  69 OUString SAL_CALL IndexEntrySupplier_Unicode::getIndexCharacter( const OUString& rIndexEntry,
  70     const lang::Locale& rLocale, const OUString& rAlgorithm ) {
  71
  72     if (loadAlgorithm( rLocale, rAlgorithm, CollatorOptions::CollatorOptions_IGNORE_CASE_ACCENT))
  73         return index->getIndexDescription(rIndexEntry);
  74     else
  75         return IndexEntrySupplier_Common::getIndexCharacter(rIndexEntry, rLocale, rAlgorithm);
  76 }
  77
  78 IndexTable::IndexTable()
  79     : start(0)
  80     , end(0)
  81     , table(nullptr)
  82 {
  83 }
  84
  85 IndexTable::~IndexTable()
  86 {
  87     if (table) free(table);
  88 }
  89
  90 void IndexTable::init(sal_Unicode start_, sal_Unicode end_, IndexKey *keys, sal_Int16 key_count, Index *index)
  91 {
  92     start=start_;
  93     end=end_;
  94     table = static_cast<sal_uInt8*>(malloc((end-start+1)*sizeof(sal_uInt8)));
  95     for (sal_Unicode i = start; i <= end; i++) {
  96         sal_Int16 j;
  97         for (j = 0; j < key_count; j++) {
  98             if (keys[j].key > 0 && (i == keys[j].key || index->compare(i, keys[j].key) == 0)) {
  99                 table[i-start] = sal::static_int_cast<sal_uInt8>(j);
 100                 break;
 101             }
 102         }
 103         if (j == key_count)
 104             table[i-start] = 0xFF;
 105     }
 106 }
 107
 108 Index::Index(const css::uno::Reference < css::uno::XComponentContext >& rxContext)
 109     : table_count(0)
 110     , key_count(0)
 111     , mkey_count(0)
 112     , collator( new CollatorImpl(rxContext) )
 113 {
 114 }
 115
 116 Index::~Index()
 117 {
 118 }
 119
 120 sal_Int16 Index::compare(sal_Unicode c1, sal_Unicode c2)
 121 {
 122     return sal::static_int_cast<sal_Int16>( collator->compareString(OUString(&c1, 1), OUString(&c2, 1)) );
 123 }
 124
 125 sal_Int16 Index::getIndexWeight(const OUString& rIndexEntry)
 126 {
 127     sal_Int32 startPos=0;
 128     if (!skipping_chars.isEmpty())
 129         while (skipping_chars.indexOf(rIndexEntry[startPos]) >= 0)
 130             startPos++;
 131     if (mkey_count > 0) {
 132         for (sal_Int16 i = 0; i < mkey_count; i++) {
 133             sal_Int32 len = keys[mkeys[i]].mkey.getLength();
 134             if (collator->compareSubstring(rIndexEntry, startPos, len,
 135                                     keys[mkeys[i]].mkey, 0, len) == 0)
 136                 return mkeys[i];
 137         }
 138     }
 139     sal_Unicode code = rIndexEntry[startPos];
 140     for (sal_Int16 i = 0; i < table_count; i++) {
 141         if (tables[i].start <= code && code <= tables[i].end)
 142             return tables[i].table[code-tables[i].start];
 143     }
 144     return 0xFF;
 145 }
 146
 147 OUString Index::getIndexDescription(const OUString& rIndexEntry)
 148 {
 149     sal_Int16 wgt = getIndexWeight(rIndexEntry);
 150     if (wgt < MAX_KEYS) {
 151         if (!keys[wgt].desc.isEmpty())
 152             return keys[wgt].desc;
 153         else if (keys[wgt].key > 0)
 154             return OUString(&keys[wgt].key, 1);
 155         else
 156             return keys[wgt].mkey;
 157     }
 158     sal_Int32 nPos=0;
 159     sal_uInt32 indexChar=rIndexEntry.iterateCodePoints(&nPos, 0);
 160     return OUString(&indexChar, 1);
 161 }
 162
 163 #define LOCALE_EN lang::Locale("en", OUString(), OUString())
 164
 165 void Index::makeIndexKeys(const lang::Locale &rLocale, const OUString &algorithm)
 166 {
 167     OUString keyStr = LocaleDataImpl::get()->getIndexKeysByAlgorithm(rLocale, algorithm);
 168
 169     if (keyStr.isEmpty()) {
 170         keyStr = LocaleDataImpl::get()->getIndexKeysByAlgorithm(LOCALE_EN,
 171                     LocaleDataImpl::get()->getDefaultIndexAlgorithm(LOCALE_EN));
 172         if (keyStr.isEmpty())
 173             throw RuntimeException();
 174     }
 175
 176     sal_Int16 len = sal::static_int_cast<sal_Int16>( keyStr.getLength() );
 177     mkey_count=key_count=0;
 178     skipping_chars=OUString();
 179     sal_Int16 i, j;
 180
 181     for (i = 0; i < len && key_count < MAX_KEYS; i++)
 182     {
 183         sal_Unicode curr = keyStr[i];
 184         sal_Unicode close = ')';
 185
 186         if (unicode::isWhiteSpace(curr))
 187             continue;
 188
 189         switch(curr) {
 190             case u'-':
 191                 if (key_count > 0 && i + 1 < len ) {
 192                     for (curr = keyStr[++i]; key_count < MAX_KEYS && keys[key_count-1].key < curr; key_count++) {
 193                         keys[key_count].key = keys[key_count-1].key+1;
 194                         keys[key_count].desc.clear();
 195                     }
 196                 } else
 197                     throw RuntimeException();
 198                 break;
 199             case u'[':
 200                 for (i++; i < len && keyStr[i] != ']'; i++) {
 201                     if (unicode::isWhiteSpace(keyStr[i])) {
 202                         continue;
 203                     } else if (keyStr[i] == '_') {
 204                         for (curr=keyStr[i-1]+1;  curr <= keyStr[i+1]; curr++)
 205                             skipping_chars+=OUStringLiteral1(curr);
 206                         i+=2;
 207                     } else {
 208                         skipping_chars+=OUStringLiteral1(keyStr[i]);
 209                     }
 210                 }
 211                 break;
 212             case u'{':
 213                 close = '}';
 214                 SAL_FALLTHROUGH;
 215             case u'(':
 216                 if (key_count > 0) {
 217                     sal_Int16 end = i+1;
 218                     for (; end < len && keyStr[end] != close; end++) ;
 219
 220                     if (end >= len) // no found
 221                         throw RuntimeException();
 222                     if (close == ')')
 223                         keys[key_count-1].desc = keyStr.copy(i+1, end-i-1);
 224                     else {
 225                         mkeys[mkey_count++]=key_count;
 226                         keys[key_count].key = 0;
 227                         keys[key_count].mkey = keyStr.copy(i+1, end-i-1);
 228                         keys[key_count++].desc.clear();
 229                     }
 230                     i=end+1;
 231                 } else
 232                     throw RuntimeException();
 233                 break;
 234             default:
 235                 keys[key_count].key = curr;
 236                 keys[key_count++].desc.clear();
 237                 break;
 238         }
 239     }
 240     for (i = 0; i < mkey_count; i++) {
 241         for (j=i+1; j < mkey_count; j++) {
 242             if (keys[mkeys[i]].mkey.getLength() < keys[mkeys[j]].mkey.getLength()) {
 243                 sal_Int16 k = mkeys[i];
 244                 mkeys[i] = mkeys[j];
 245                 mkeys[j] = k;
 246             }
 247         }
 248     }
 249 }
 250
 251 void Index::init(const lang::Locale &rLocale, const OUString& algorithm)
 252 {
 253     makeIndexKeys(rLocale, algorithm);
 254
 255     Sequence< UnicodeScript > scriptList = LocaleDataImpl::get()->getUnicodeScripts( rLocale );
 256
 257     if (scriptList.getLength() == 0) {
 258         scriptList = LocaleDataImpl::get()->getUnicodeScripts(LOCALE_EN);
 259         if (scriptList.getLength() == 0)
 260             throw RuntimeException();
 261     }
 262
 263     table_count = sal::static_int_cast<sal_Int16>( scriptList.getLength() );
 264     if (table_count > MAX_TABLES)
 265         throw RuntimeException();
 266
 267     collator->loadCollatorAlgorithm(algorithm, rLocale, CollatorOptions::CollatorOptions_IGNORE_CASE_ACCENT);
 268     sal_Int16 j=0;
 269     sal_Unicode start = unicode::getUnicodeScriptStart((UnicodeScript)0);
 270     sal_Unicode end = unicode::getUnicodeScriptEnd((UnicodeScript)0);
 271     for (sal_Int32 i= (scriptList[0] == (UnicodeScript)0) ? 1 : 0; i< scriptList.getLength(); i++) {
 272         if (unicode::getUnicodeScriptStart(scriptList[i]) != end+1) {
 273             tables[j++].init(start, end, keys, key_count, this);
 274             start = unicode::getUnicodeScriptStart(scriptList[i]);
 275         }
 276         end = unicode::getUnicodeScriptEnd(scriptList[i]);
 277     }
 278     tables[j++].init(start, end, keys, key_count, this);
 279     table_count = j;
 280 }
 281
 282 } } } }
 283
 284 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */