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