LCOV - code coverage report
Current view: top level - comphelper/source/misc - string.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 242 0.0 %
Date: 2014-04-14 Functions: 0 29 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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 "sal/config.h"
      21             : 
      22             : #include <cstddef>
      23             : #include <string.h>
      24             : #include <vector>
      25             : #include <algorithm>
      26             : 
      27             : #include <rtl/ustring.hxx>
      28             : #include <rtl/ustrbuf.hxx>
      29             : #include <rtl/string.hxx>
      30             : #include <rtl/strbuf.hxx>
      31             : #include <sal/types.h>
      32             : 
      33             : #include <comphelper/string.hxx>
      34             : #include <comphelper/stl_types.hxx>
      35             : 
      36             : #include <com/sun/star/i18n/BreakIterator.hpp>
      37             : #include <com/sun/star/i18n/CharType.hpp>
      38             : #include <com/sun/star/i18n/Collator.hpp>
      39             : 
      40             : 
      41             : namespace comphelper { namespace string {
      42             : 
      43             : namespace
      44             : {
      45           0 :     template <typename T, typename C> T tmpl_stripStart(const T &rIn,
      46             :         const C cRemove)
      47             :     {
      48           0 :         if (rIn.isEmpty())
      49           0 :             return rIn;
      50             : 
      51           0 :         sal_Int32 i = 0;
      52             : 
      53           0 :         while (i < rIn.getLength())
      54             :         {
      55           0 :             if (rIn[i] != cRemove)
      56           0 :                 break;
      57           0 :             ++i;
      58             :         }
      59             : 
      60           0 :         return rIn.copy(i);
      61             :     }
      62             : }
      63             : 
      64           0 : OString stripStart(const OString &rIn, sal_Char c)
      65             : {
      66           0 :     return tmpl_stripStart<OString, sal_Char>(rIn, c);
      67             : }
      68             : 
      69           0 : OUString stripStart(const OUString &rIn, sal_Unicode c)
      70             : {
      71           0 :     return tmpl_stripStart<OUString, sal_Unicode>(rIn, c);
      72             : }
      73             : 
      74             : namespace
      75             : {
      76           0 :     template <typename T, typename C> T tmpl_stripEnd(const T &rIn,
      77             :         const C cRemove)
      78             :     {
      79           0 :         if (rIn.isEmpty())
      80           0 :             return rIn;
      81             : 
      82           0 :         sal_Int32 i = rIn.getLength();
      83             : 
      84           0 :         while (i > 0)
      85             :         {
      86           0 :             if (rIn[i-1] != cRemove)
      87           0 :                 break;
      88           0 :             --i;
      89             :         }
      90             : 
      91           0 :         return rIn.copy(0, i);
      92             :     }
      93             : }
      94             : 
      95           0 : OString stripEnd(const OString &rIn, sal_Char c)
      96             : {
      97           0 :     return tmpl_stripEnd<OString, sal_Char>(rIn, c);
      98             : }
      99             : 
     100           0 : OUString stripEnd(const OUString &rIn, sal_Unicode c)
     101             : {
     102           0 :     return tmpl_stripEnd<OUString, sal_Unicode>(rIn, c);
     103             : }
     104             : 
     105           0 : OString strip(const OString &rIn, sal_Char c)
     106             : {
     107           0 :     return stripEnd(stripStart(rIn, c), c);
     108             : }
     109             : 
     110           0 : OUString strip(const OUString &rIn, sal_Unicode c)
     111             : {
     112           0 :     return stripEnd(stripStart(rIn, c), c);
     113             : }
     114             : 
     115             : namespace
     116             : {
     117           0 :     template <typename T, typename C> sal_Int32 tmpl_getTokenCount(const T &rIn,
     118             :         C cTok)
     119             :     {
     120             :         // Empty String: TokenCount by Definition is 0
     121           0 :         if (rIn.isEmpty())
     122           0 :             return 0;
     123             : 
     124           0 :         sal_Int32 nTokCount = 1;
     125           0 :         for (sal_Int32 i = 0; i < rIn.getLength(); ++i)
     126             :         {
     127           0 :             if (rIn[i] == cTok)
     128           0 :                 ++nTokCount;
     129             :         }
     130           0 :         return nTokCount;
     131             :     }
     132             : }
     133             : 
     134           0 : sal_Int32 getTokenCount(const OString &rIn, sal_Char cTok)
     135             : {
     136           0 :     return tmpl_getTokenCount<OString, sal_Char>(rIn, cTok);
     137             : }
     138             : 
     139           0 : sal_Int32 getTokenCount(const OUString &rIn, sal_Unicode cTok)
     140             : {
     141           0 :     return tmpl_getTokenCount<OUString, sal_Unicode>(rIn, cTok);
     142             : }
     143             : 
     144           0 : sal_uInt32 decimalStringToNumber(
     145             :     OUString const & str )
     146             : {
     147           0 :     sal_uInt32 result = 0;
     148           0 :     for( sal_Int32 i = 0 ; i < str.getLength() ; )
     149             :     {
     150           0 :         sal_uInt32 c = str.iterateCodePoints(&i);
     151           0 :         sal_uInt32 value = 0;
     152           0 :         if( c <= 0x0039)    // ASCII decimal digits, most common
     153           0 :             value = c - 0x0030;
     154           0 :         else if( c >= 0x1D7F6 )    // mathematical monospace digits
     155           0 :             value = c - 0x1D7F6;
     156           0 :         else if( c >= 0x1D7EC ) // mathematical sans-serif bold digits
     157           0 :             value = c - 0x1D7EC;
     158           0 :         else if( c >= 0x1D7E2 ) // mathematical sans-serif digits
     159           0 :             value = c - 0x1D7E2;
     160           0 :         else if( c >= 0x1D7D8 ) // mathematical double-struck digits
     161           0 :             value = c - 0x1D7D8;
     162           0 :         else if( c >= 0x1D7CE ) // mathematical bold digits
     163           0 :             value = c - 0x1D7CE;
     164           0 :         else if( c >= 0x11066 ) // brahmi digits
     165           0 :             value = c - 0x11066;
     166           0 :         else if( c >= 0x104A0 ) // osmanya digits
     167           0 :             value = c - 0x104A0;
     168           0 :         else if( c >= 0xFF10 ) // fullwidth digits
     169           0 :             value = c - 0xFF10;
     170           0 :         else if( c >= 0xABF0 ) // meetei mayek digits
     171           0 :             value = c - 0xABF0;
     172           0 :         else if( c >= 0xAA50 ) // cham digits
     173           0 :             value = c - 0xAA50;
     174           0 :         else if( c >= 0xA9D0 ) // javanese digits
     175           0 :             value = c - 0xA9D0;
     176           0 :         else if( c >= 0xA900 ) // kayah li digits
     177           0 :             value = c - 0xA900;
     178           0 :         else if( c >= 0xA8D0 ) // saurashtra digits
     179           0 :             value = c - 0xA8D0;
     180           0 :         else if( c >= 0xA620 ) // vai digits
     181           0 :             value = c - 0xA620;
     182           0 :         else if( c >= 0x1C50 ) // ol chiki digits
     183           0 :             value = c - 0x1C50;
     184           0 :         else if( c >= 0x1C40 ) // lepcha digits
     185           0 :             value = c - 0x1C40;
     186           0 :         else if( c >= 0x1BB0 ) // sundanese digits
     187           0 :             value = c - 0x1BB0;
     188           0 :         else if( c >= 0x1B50 ) // balinese digits
     189           0 :             value = c - 0x1B50;
     190           0 :         else if( c >= 0x1A90 ) // tai tham tham digits
     191           0 :             value = c - 0x1A90;
     192           0 :         else if( c >= 0x1A80 ) // tai tham hora digits
     193           0 :             value = c - 0x1A80;
     194           0 :         else if( c >= 0x19D0 ) // new tai lue digits
     195           0 :             value = c - 0x19D0;
     196           0 :         else if( c >= 0x1946 ) // limbu digits
     197           0 :             value = c - 0x1946;
     198           0 :         else if( c >= 0x1810 ) // mongolian digits
     199           0 :             value = c - 0x1810;
     200           0 :         else if( c >= 0x17E0 ) // khmer digits
     201           0 :             value = c - 0x17E0;
     202           0 :         else if( c >= 0x1090 ) // myanmar shan digits
     203           0 :             value = c - 0x1090;
     204           0 :         else if( c >= 0x1040 ) // myanmar digits
     205           0 :             value = c - 0x1040;
     206           0 :         else if( c >= 0x0F20 ) // tibetan digits
     207           0 :             value = c - 0x0F20;
     208           0 :         else if( c >= 0x0ED0 ) // lao digits
     209           0 :             value = c - 0x0ED0;
     210           0 :         else if( c >= 0x0E50 ) // thai digits
     211           0 :             value = c - 0x0E50;
     212           0 :         else if( c >= 0x0D66 ) // malayalam digits
     213           0 :             value = c - 0x0D66;
     214           0 :         else if( c >= 0x0CE6 ) // kannada digits
     215           0 :             value = c - 0x0CE6;
     216           0 :         else if( c >= 0x0C66 ) // telugu digits
     217           0 :             value = c - 0x0C66;
     218           0 :         else if( c >= 0x0BE6 ) // tamil digits
     219           0 :             value = c - 0x0BE6;
     220           0 :         else if( c >= 0x0B66 ) // odia digits
     221           0 :             value = c - 0x0B66;
     222           0 :         else if( c >= 0x0AE6 ) // gujarati digits
     223           0 :             value = c - 0x0AE6;
     224           0 :         else if( c >= 0x0A66 ) // gurmukhi digits
     225           0 :             value = c - 0x0A66;
     226           0 :         else if( c >= 0x09E6 ) // bengali digits
     227           0 :             value = c - 0x09E6;
     228           0 :         else if( c >= 0x0966 ) // devanagari digit
     229           0 :             value = c - 0x0966;
     230           0 :         else if( c >= 0x07C0 ) // nko digits
     231           0 :             value = c - 0x07C0;
     232           0 :         else if( c >= 0x06F0 ) // extended arabic-indic digits
     233           0 :             value = c - 0x06F0;
     234           0 :         else if( c >= 0x0660 ) // arabic-indic digits
     235           0 :             value = c - 0x0660;
     236           0 :         result = result * 10 + value;
     237             :     }
     238           0 :     return result;
     239             : }
     240             : 
     241             : using namespace ::com::sun::star;
     242             : 
     243             : // convert between sequence of string and comma separated string
     244             : 
     245           0 : OUString convertCommaSeparated(
     246             :     uno::Sequence< OUString > const& i_rSeq)
     247             : {
     248           0 :     OUStringBuffer buf;
     249             :     ::comphelper::intersperse(
     250           0 :         i_rSeq.begin(), i_rSeq.end(), ::comphelper::OUStringBufferAppender(buf), OUString( ", " ));
     251           0 :     return buf.makeStringAndClear();
     252             : }
     253             : 
     254             : uno::Sequence< OUString >
     255           0 :     convertCommaSeparated( OUString const& i_rString )
     256             : {
     257           0 :     std::vector< OUString > vec;
     258           0 :     sal_Int32 idx = 0;
     259           0 :     do {
     260             :       OUString kw =
     261           0 :         i_rString.getToken(0, static_cast<sal_Unicode> (','), idx);
     262           0 :       kw = kw.trim();
     263           0 :       if (!kw.isEmpty()) {
     264           0 :           vec.push_back(kw);
     265           0 :       }
     266           0 :     } while (idx >= 0);
     267           0 :     uno::Sequence< OUString > kws(vec.size());
     268           0 :     std::copy(vec.begin(), vec.end(), kws.begin());
     269           0 :     return kws;
     270             : }
     271             : 
     272             : 
     273           0 : sal_Int32 compareNatural( const OUString & rLHS, const OUString & rRHS,
     274             :     const uno::Reference< i18n::XCollator > &rCollator,
     275             :     const uno::Reference< i18n::XBreakIterator > &rBI,
     276             :     const lang::Locale &rLocale )
     277             : {
     278           0 :     sal_Int32 nRet = 0;
     279             : 
     280           0 :     sal_Int32 nLHSLastNonDigitPos = 0;
     281           0 :     sal_Int32 nRHSLastNonDigitPos = 0;
     282           0 :     sal_Int32 nLHSFirstDigitPos = 0;
     283           0 :     sal_Int32 nRHSFirstDigitPos = 0;
     284             : 
     285           0 :     while (nLHSFirstDigitPos < rLHS.getLength() || nRHSFirstDigitPos < rRHS.getLength())
     286             :     {
     287             :         sal_Int32 nLHSChunkLen;
     288             :         sal_Int32 nRHSChunkLen;
     289             : 
     290             :         //Compare non digit block as normal strings
     291           0 :         nLHSFirstDigitPos = rBI->nextCharBlock(rLHS, nLHSLastNonDigitPos,
     292           0 :             rLocale, i18n::CharType::DECIMAL_DIGIT_NUMBER);
     293           0 :         nRHSFirstDigitPos = rBI->nextCharBlock(rRHS, nRHSLastNonDigitPos,
     294           0 :             rLocale, i18n::CharType::DECIMAL_DIGIT_NUMBER);
     295           0 :         if (nLHSFirstDigitPos == -1)
     296           0 :             nLHSFirstDigitPos = rLHS.getLength();
     297           0 :         if (nRHSFirstDigitPos == -1)
     298           0 :             nRHSFirstDigitPos = rRHS.getLength();
     299           0 :         nLHSChunkLen = nLHSFirstDigitPos - nLHSLastNonDigitPos;
     300           0 :         nRHSChunkLen = nRHSFirstDigitPos - nRHSLastNonDigitPos;
     301             : 
     302           0 :         nRet = rCollator->compareSubstring(rLHS, nLHSLastNonDigitPos,
     303           0 :             nLHSChunkLen, rRHS, nRHSLastNonDigitPos, nRHSChunkLen);
     304           0 :         if (nRet != 0)
     305           0 :             break;
     306             : 
     307             :         //Compare digit block as one number vs another
     308           0 :         nLHSLastNonDigitPos = rBI->endOfCharBlock(rLHS, nLHSFirstDigitPos,
     309           0 :             rLocale, i18n::CharType::DECIMAL_DIGIT_NUMBER);
     310           0 :         nRHSLastNonDigitPos = rBI->endOfCharBlock(rRHS, nRHSFirstDigitPos,
     311           0 :             rLocale, i18n::CharType::DECIMAL_DIGIT_NUMBER);
     312           0 :         if (nLHSLastNonDigitPos == -1)
     313           0 :             nLHSLastNonDigitPos = rLHS.getLength();
     314           0 :         if (nRHSLastNonDigitPos == -1)
     315           0 :             nRHSLastNonDigitPos = rRHS.getLength();
     316           0 :         nLHSChunkLen = nLHSLastNonDigitPos - nLHSFirstDigitPos;
     317           0 :         nRHSChunkLen = nRHSLastNonDigitPos - nRHSFirstDigitPos;
     318             : 
     319             :         //To-Do: Possibly scale down those unicode codepoints that relate to
     320             :         //numbers outside of the normal 0-9 range, e.g. see GetLocalizedChar in
     321             :         //vcl
     322             : 
     323           0 :         sal_uInt32 nLHS = comphelper::string::decimalStringToNumber(rLHS.copy(nLHSFirstDigitPos, nLHSChunkLen));
     324           0 :         sal_uInt32 nRHS = comphelper::string::decimalStringToNumber(rRHS.copy(nRHSFirstDigitPos, nRHSChunkLen));
     325             : 
     326           0 :         nRet = nLHS-nRHS;
     327           0 :         if (nRet != 0)
     328           0 :             break;
     329             :     }
     330             : 
     331             :     //Squeeze these down to -1, 0, 1 in case there is an assumption those are
     332             :     //the only valid returns
     333           0 :     if (nRet > 0)
     334           0 :         nRet = 1;
     335           0 :     else if (nRet < 0)
     336           0 :         nRet = -1;
     337             : 
     338           0 :     return nRet;
     339             : }
     340             : 
     341           0 : NaturalStringSorter::NaturalStringSorter(
     342             :     const uno::Reference< uno::XComponentContext > &rContext,
     343           0 :     const lang::Locale &rLocale) : m_aLocale(rLocale)
     344             : {
     345           0 :     m_xCollator = i18n::Collator::create( rContext );
     346           0 :     m_xCollator->loadDefaultCollator(m_aLocale, 0);
     347           0 :     m_xBI = i18n::BreakIterator::create( rContext );
     348           0 : }
     349             : 
     350             : namespace
     351             : {
     352             :     //do OPER on each element of the string, return false
     353             :     //if any OPER is false, true otherwise
     354             :     template <bool (*OPER)(sal_Unicode), typename T>
     355           0 :     bool tmpl_is_OPER_AsciiString(const T &rString)
     356             :     {
     357           0 :         for (sal_Int32 i = 0; i < rString.getLength(); ++i)
     358             :         {
     359           0 :             if (!OPER(rString[i]))
     360           0 :                 return false;
     361             :         }
     362           0 :         return true;
     363             :     }
     364             : }
     365             : 
     366           0 : bool isdigitAsciiString(const OString &rString)
     367             : {
     368           0 :     return tmpl_is_OPER_AsciiString<isdigitAscii>(rString);
     369             : }
     370             : 
     371           0 : bool isdigitAsciiString(const OUString &rString)
     372             : {
     373           0 :     return tmpl_is_OPER_AsciiString<isdigitAscii>(rString);
     374             : }
     375             : 
     376             : namespace
     377             : {
     378           0 :     template <typename T, typename O> T tmpl_reverseString(const T &rIn)
     379             :     {
     380           0 :         if (rIn.isEmpty())
     381           0 :             return rIn;
     382             : 
     383           0 :         sal_Int32 i = rIn.getLength();
     384           0 :         O sBuf(i);
     385           0 :         while (i)
     386           0 :             sBuf.append(rIn[--i]);
     387           0 :         return sBuf.makeStringAndClear();
     388             :     }
     389             : }
     390             : 
     391           0 : OUString reverseString(const OUString &rStr)
     392             : {
     393           0 :     return tmpl_reverseString<OUString, OUStringBuffer>(rStr);
     394             : }
     395             : 
     396           0 : OString reverseString(const OString &rStr)
     397             : {
     398           0 :     return tmpl_reverseString<OString, OStringBuffer>(rStr);
     399             : }
     400             : 
     401           0 : sal_Int32 indexOfAny(OUString const& rIn,
     402             :         sal_Unicode const*const pChars, sal_Int32 const nPos)
     403             : {
     404           0 :     for (sal_Int32 i = nPos; i < rIn.getLength(); ++i)
     405             :     {
     406           0 :         sal_Unicode const c = rIn[i];
     407           0 :         for (sal_Unicode const* pChar = pChars; *pChar; ++pChar)
     408             :         {
     409           0 :             if (c == *pChar)
     410             :             {
     411           0 :                 return i;
     412             :             }
     413             :         }
     414             :     }
     415           0 :     return -1;
     416             : }
     417             : 
     418           0 : OUString setToken(const OUString& rIn, sal_Int32 nToken, sal_Unicode cTok,
     419             :     const OUString& rNewToken)
     420             : {
     421           0 :     const sal_Unicode* pStr = rIn.getStr();
     422           0 :     sal_Int32 nLen = rIn.getLength();
     423           0 :     sal_Int32 nTok = 0;
     424           0 :     sal_Int32 nFirstChar = 0;
     425           0 :     sal_Int32 i = 0;
     426             : 
     427             :     // Determine token position and length
     428           0 :     while ( i < nLen )
     429             :     {
     430             :         // Increase token count if match
     431           0 :         if (*pStr == cTok)
     432             :         {
     433           0 :             ++nTok;
     434             : 
     435           0 :             if (nTok == nToken)
     436           0 :                 nFirstChar = i+1;
     437           0 :             else if (nTok > nToken)
     438           0 :                 break;
     439             :         }
     440             : 
     441             :         ++pStr,
     442           0 :         ++i;
     443             :     }
     444             : 
     445           0 :     if (nTok >= nToken)
     446           0 :         return rIn.replaceAt(nFirstChar, i-nFirstChar, rNewToken);
     447           0 :     return rIn;
     448             : }
     449             : 
     450             : } }
     451             : 
     452             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10