i18npool/source/transliteration/transliteration_Ignore.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
  21 #include <utility>
  22 #include <comphelper/string.hxx>
  23 #include <transliteration_Ignore.hxx>
  24
  25 using namespace com::sun::star::uno;
  26
  27 namespace com { namespace sun { namespace star { namespace i18n {
  28
  29 inline sal_Int32 Min( sal_Int32 a, sal_Int32 b ) { return a > b ? b : a; }
  30
  31 sal_Bool SAL_CALL
  32 transliteration_Ignore::equals(const OUString& str1, sal_Int32 pos1, sal_Int32 nCount1, sal_Int32& nMatch1,
  33         const OUString& str2, sal_Int32 pos2, sal_Int32 nCount2, sal_Int32& nMatch2 ) throw(RuntimeException)
  34 {
  35         Sequence< sal_Int32 > offset1;
  36         Sequence< sal_Int32 > offset2;
  37
  38         // The method folding is defined in a sub class.
  39         OUString s1 = this->folding( str1, pos1, nCount1, offset1);
  40         OUString s2 = this->folding( str2, pos2, nCount2, offset2);
  41
  42         const sal_Unicode * p1 = s1.getStr();
  43         const sal_Unicode * p2 = s2.getStr();
  44         sal_Int32 length = Min(s1.getLength(), s2.getLength());
  45         sal_Int32 nmatch;
  46
  47         for ( nmatch = 0; nmatch < length; nmatch++)
  48             if (*p1++ != *p2++)
  49                 break;
  50
  51         if (nmatch > 0) {
  52             nMatch1 = offset1[ nmatch - 1 ] + 1; // Subtract 1 from nmatch because the index starts from zero.
  53             nMatch2 = offset2[ nmatch - 1 ] + 1; // And then, add 1 to position because it means the number of character matched.
  54         }
  55         else {
  56             nMatch1 = 0;  // No character was matched.
  57             nMatch2 = 0;
  58         }
  59
  60         return (nmatch == s1.getLength()) && (nmatch == s2.getLength());
  61 }
  62
  63
  64 Sequence< OUString > SAL_CALL
  65 transliteration_Ignore::transliterateRange( const OUString& str1, const OUString& str2 ) throw(RuntimeException)
  66 {
  67         if (str1.isEmpty() || str2.isEmpty())
  68             throw RuntimeException();
  69
  70         Sequence< OUString > r(2);
  71         r[0] = str1.copy(0, 1);
  72         r[1] = str2.copy(0, 1);
  73         return r;
  74 }
  75
  76
  77 sal_Int16 SAL_CALL
  78 transliteration_Ignore::getType() throw(RuntimeException)
  79 {
  80         // The type is also defined in com/sun/star/util/TransliterationType.hdl
  81         return TransliterationType::IGNORE;
  82 }
  83
  84
  85 OUString SAL_CALL
  86 transliteration_Ignore::transliterate( const OUString& inStr, sal_Int32 startPos, sal_Int32 nCount,
  87         Sequence< sal_Int32 >& offset  ) throw(RuntimeException)
  88 {
  89         // The method folding is defined in a sub class.
  90         return this->folding( inStr, startPos, nCount, offset);
  91 }
  92
  93 Sequence< OUString > SAL_CALL
  94 transliteration_Ignore::transliterateRange( const OUString& str1, const OUString& str2,
  95         XTransliteration& t1, XTransliteration& t2 ) throw(RuntimeException)
  96 {
  97         if (str1.isEmpty() || str2.isEmpty())
  98             throw RuntimeException();
  99
 100         Sequence< sal_Int32 > offset;
 101         OUString s11 = t1.transliterate( str1, 0, 1, offset );
 102         OUString s12 = t1.transliterate( str2, 0, 1, offset );
 103         OUString s21 = t2.transliterate( str1, 0, 1, offset );
 104         OUString s22 = t2.transliterate( str2, 0, 1, offset );
 105
 106         if ( (s11 == s21) && (s12 == s22) ) {
 107             Sequence< OUString > r(2);
 108             r[0] = s11;
 109             r[1] = s12;
 110             return r;
 111         }
 112
 113         Sequence< OUString > r(4);
 114         r[0] = s11;
 115         r[1] = s12;
 116         r[2] = s21;
 117         r[3] = s22;
 118         return r;
 119 }
 120
 121 OUString SAL_CALL
 122 transliteration_Ignore::folding( const OUString& inStr, sal_Int32 startPos,
 123     sal_Int32 nCount, Sequence< sal_Int32 >& offset)
 124     throw(RuntimeException)
 125 {
 126     // Create a string buffer which can hold nCount + 1 characters.
 127     // The reference count is 1 now.
 128     rtl_uString * newStr = rtl_uString_alloc(nCount);
 129     sal_Unicode * dst = newStr->buffer;
 130     const sal_Unicode * src = inStr.getStr() + startPos;
 131
 132     // Allocate nCount length to offset argument.
 133     sal_Int32 *p = 0;
 134     sal_Int32 position = 0;
 135     if (useOffset) {
 136         offset.realloc( nCount );
 137         p = offset.getArray();
 138         position = startPos;
 139     }
 140
 141     if (map) {
 142         sal_Unicode previousChar = *src ++;
 143         sal_Unicode currentChar;
 144
 145         // Translation
 146         while (-- nCount > 0) {
 147             currentChar = *src ++;
 148
 149             Mapping *m;
 150             for (m = map; m->replaceChar; m++) {
 151                 if (previousChar == m->previousChar &&  currentChar == m->currentChar ) {
 152                     if (useOffset) {
 153                         if (! m->two2one)
 154                             *p++ = position;
 155                         position++;
 156                         *p++ = position++;
 157                     }
 158                     *dst++ = m->replaceChar;
 159                     if (!m->two2one)
 160                         *dst++ = currentChar;
 161                     previousChar = *src++;
 162                     nCount--;
 163                     break;
 164                 }
 165             }
 166
 167             if (! m->replaceChar) {
 168                 if (useOffset)
 169                     *p ++ = position ++;
 170                 *dst ++ = previousChar;
 171                 previousChar = currentChar;
 172             }
 173         }
 174
 175         if (nCount == 0) {
 176             if (useOffset)
 177                 *p = position;
 178             *dst ++ = previousChar;
 179         }
 180     } else {
 181         // Translation
 182         while (nCount -- > 0) {
 183             sal_Unicode c = *src++;
 184             c = func ? func( c) : (*table)[ c ];
 185             if (c != 0xffff)
 186                 *dst ++ = c;
 187             if (useOffset) {
 188                 if (c != 0xffff)
 189                     *p ++ = position;
 190                 position++;
 191             }
 192         }
 193     }
 194     newStr->length = sal_Int32(dst - newStr->buffer);
 195     if (useOffset)
 196       offset.realloc(newStr->length);
 197     *dst = (sal_Unicode) 0;
 198
 199     return OUString(newStr, SAL_NO_ACQUIRE); // take ownership
 200 }
 201
 202 sal_Unicode SAL_CALL
 203 transliteration_Ignore::transliterateChar2Char( sal_Unicode inChar) throw(RuntimeException, MultipleCharsOutputException)
 204 {
 205     return func ? func( inChar) : table ? (*table)[ inChar ] : inChar;
 206 }
 207
 208 } } } }
 209
 210 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */