LCOV - code coverage report
Current view: top level - unotools/source/i18n - charclass.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 81 168 48.2 %
Date: 2015-06-13 12:38:46 Functions: 20 26 76.9 %
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 <comphelper/processfactory.hxx>
      21             : #include <sal/log.hxx>
      22             : #include <unotools/charclass.hxx>
      23             : #include <rtl/character.hxx>
      24             : 
      25             : #include <com/sun/star/i18n/CharacterClassification.hpp>
      26             : 
      27             : using namespace ::com::sun::star;
      28             : using namespace ::com::sun::star::i18n;
      29             : using namespace ::com::sun::star::uno;
      30             : 
      31        5775 : CharClass::CharClass(
      32             :             const Reference< uno::XComponentContext > & rxContext,
      33             :             const LanguageTag& rLanguageTag
      34             :             )
      35             :     :
      36        5775 :         maLanguageTag( rLanguageTag)
      37             : {
      38        5775 :     xCC = CharacterClassification::create( rxContext );
      39        5775 : }
      40             : 
      41       25886 : CharClass::CharClass(
      42             :             const LanguageTag& rLanguageTag )
      43             :     :
      44       25886 :         maLanguageTag( rLanguageTag)
      45             : {
      46       25886 :     xCC = CharacterClassification::create( comphelper::getProcessComponentContext() );
      47       25886 : }
      48             : 
      49       31537 : CharClass::~CharClass()
      50             : {
      51       31537 : }
      52             : 
      53   262144116 : void CharClass::setLanguageTag( const LanguageTag& rLanguageTag )
      54             : {
      55   262144116 :     ::osl::MutexGuard aGuard( aMutex );
      56   262144116 :     maLanguageTag = rLanguageTag;
      57   262144116 : }
      58             : 
      59   134175833 : const LanguageTag& CharClass::getLanguageTag() const
      60             : {
      61   134175833 :     ::osl::MutexGuard aGuard( aMutex );
      62   134175833 :     return maLanguageTag;
      63             : }
      64             : 
      65   853054757 : const ::com::sun::star::lang::Locale& CharClass::getMyLocale() const
      66             : {
      67   853054757 :     ::osl::MutexGuard aGuard( aMutex );
      68   853054757 :     return maLanguageTag.getLocale();
      69             : }
      70             : 
      71             : // static
      72       29027 : bool CharClass::isAsciiNumeric( const OUString& rStr )
      73             : {
      74       29027 :     if ( rStr.isEmpty() )
      75           0 :         return false;
      76       29027 :     const sal_Unicode* p = rStr.getStr();
      77       29027 :     const sal_Unicode* const pStop = p + rStr.getLength();
      78             : 
      79           5 :     do
      80             :     {
      81       29030 :         if ( !rtl::isAsciiDigit( *p ) )
      82       29025 :             return false;
      83             :     }
      84             :     while ( ++p < pStop );
      85             : 
      86           2 :     return true;
      87             : }
      88             : 
      89             : // static
      90           0 : bool CharClass::isAsciiAlpha( const OUString& rStr )
      91             : {
      92           0 :     if ( rStr.isEmpty() )
      93           0 :         return false;
      94           0 :     const sal_Unicode* p = rStr.getStr();
      95           0 :     const sal_Unicode* const pStop = p + rStr.getLength();
      96             : 
      97           0 :     do
      98             :     {
      99           0 :         if ( !rtl::isAsciiAlpha( *p ) )
     100           0 :             return false;
     101             :     }
     102             :     while ( ++p < pStop );
     103             : 
     104           0 :     return true;
     105             : }
     106             : 
     107           0 : bool CharClass::isAlpha( const OUString& rStr, sal_Int32 nPos ) const
     108             : {
     109           0 :     sal_Unicode c = rStr[nPos];
     110           0 :     if ( c < 128 )
     111           0 :         return rtl::isAsciiAlpha( c );
     112             : 
     113             :     try
     114             :     {
     115           0 :         if ( xCC.is() )
     116           0 :             return  (xCC->getCharacterType( rStr, nPos, getMyLocale() ) &
     117           0 :                      nCharClassAlphaType) != 0;
     118             :         else
     119           0 :             return false;
     120             :     }
     121           0 :     catch ( const Exception& )
     122             :     {
     123             :         SAL_WARN( "unotools.i18n", "isAlpha: Exception caught!" );
     124           0 :         return false;
     125             :     }
     126             : }
     127             : 
     128     1243574 : bool CharClass::isLetter( const OUString& rStr, sal_Int32 nPos ) const
     129             : {
     130     1243574 :     sal_Unicode c = rStr[nPos];
     131     1243574 :     if ( c < 128 )
     132     1242122 :         return rtl::isAsciiAlpha( c );
     133             : 
     134             :     try
     135             :     {
     136        1452 :         if ( xCC.is() )
     137        1452 :             return  (xCC->getCharacterType( rStr, nPos, getMyLocale() ) &
     138        1452 :                      nCharClassLetterType) != 0;
     139             :         else
     140           0 :             return false;
     141             :     }
     142           0 :     catch ( const Exception& )
     143             :     {
     144             :         SAL_WARN( "unotools.i18n", "isLetter: Exception caught!" );
     145           0 :         return false;
     146             :     }
     147             : }
     148             : 
     149           0 : bool CharClass::isLetter( const OUString& rStr ) const
     150             : {
     151             :     try
     152             :     {
     153           0 :         if ( xCC.is() )
     154           0 :             return isLetterType( xCC->getStringType( rStr, 0, rStr.getLength(), getMyLocale() ) );
     155             :         else
     156           0 :             return false;
     157             :     }
     158           0 :     catch ( const Exception& )
     159             :     {
     160             :         SAL_WARN( "unotools.i18n", "isLetter: Exception caught!" );
     161           0 :         return false;
     162             :     }
     163             : }
     164             : 
     165         362 : bool CharClass::isDigit( const OUString& rStr, sal_Int32 nPos ) const
     166             : {
     167         362 :     sal_Unicode c = rStr[ nPos ];
     168         362 :     if ( c < 128 )
     169          25 :         return rtl::isAsciiDigit( c );
     170             : 
     171             :     try
     172             :     {
     173         337 :         if ( xCC.is() )
     174         337 :             return  (xCC->getCharacterType( rStr, nPos, getMyLocale() ) &
     175         337 :                      KCharacterType::DIGIT) != 0;
     176             :         else
     177           0 :             return false;
     178             :     }
     179           0 :     catch ( const Exception& )
     180             :     {
     181             :         SAL_WARN( "unotools.i18n", "isDigit: Exception caught!" );
     182           0 :         return false;
     183             :     }
     184             : }
     185             : 
     186           0 : bool CharClass::isNumeric( const OUString& rStr ) const
     187             : {
     188             :     try
     189             :     {
     190           0 :         if ( xCC.is() )
     191           0 :             return isNumericType( xCC->getStringType( rStr, 0, rStr.getLength(), getMyLocale() ) );
     192             :         else
     193           0 :             return false;
     194             :     }
     195           0 :     catch ( const Exception& )
     196             :     {
     197             :         SAL_WARN( "unotools.i18n", "isNumeric: Exception caught!" );
     198           0 :         return false;
     199             :     }
     200             : }
     201             : 
     202           0 : bool CharClass::isAlphaNumeric( const OUString& rStr, sal_Int32 nPos ) const
     203             : {
     204           0 :     sal_Unicode c = rStr[nPos];
     205           0 :     if ( c < 128 )
     206           0 :         return rtl::isAsciiAlphanumeric( c );
     207             : 
     208             :     try
     209             :     {
     210           0 :         if ( xCC.is() )
     211           0 :             return  (xCC->getCharacterType( rStr, nPos, getMyLocale() ) &
     212           0 :                 (nCharClassAlphaType | KCharacterType::DIGIT)) != 0;
     213             :         else
     214           0 :             return false;
     215             :     }
     216           0 :     catch ( const Exception& )
     217             :     {
     218             :         SAL_WARN( "unotools.i18n", "isAlphaNumeric: Exception caught!" );
     219           0 :         return false;
     220             :     }
     221             : }
     222             : 
     223       97535 : bool CharClass::isLetterNumeric( const OUString& rStr, sal_Int32 nPos ) const
     224             : {
     225       97535 :     sal_Unicode c = rStr[nPos];
     226       97535 :     if ( c < 128 )
     227       93335 :         return rtl::isAsciiAlphanumeric( c );
     228             : 
     229             :     try
     230             :     {
     231        4200 :         if ( xCC.is() )
     232        4200 :             return  (xCC->getCharacterType( rStr, nPos, getMyLocale() ) &
     233        4200 :                      (nCharClassLetterType | KCharacterType::DIGIT)) != 0;
     234             :         else
     235           0 :             return false;
     236             :     }
     237           0 :     catch ( const Exception& )
     238             :     {
     239             :         SAL_WARN( "unotools.i18n", "isLetterNumeric: Exception caught!" );
     240           0 :         return false;
     241             :     }
     242             : }
     243             : 
     244    91077689 : bool CharClass::isLetterNumeric( const OUString& rStr ) const
     245             : {
     246             :     try
     247             :     {
     248    91077689 :         if ( xCC.is() )
     249    91077689 :             return isLetterNumericType( xCC->getStringType( rStr, 0, rStr.getLength(), getMyLocale() ) );
     250             :         else
     251           0 :             return false;
     252             :     }
     253           0 :     catch ( const Exception& )
     254             :     {
     255             :         SAL_WARN( "unotools.i18n", "isLetterNumeric: Exception caught!" );
     256           0 :         return false;
     257             :     }
     258             : }
     259             : 
     260           2 : OUString CharClass::titlecase(const OUString& rStr, sal_Int32 nPos, sal_Int32 nCount) const
     261             : {
     262             :     try
     263             :     {
     264           2 :         if ( xCC.is() )
     265           2 :             return xCC->toTitle( rStr, nPos, nCount, getMyLocale() );
     266             :         else
     267           0 :             return rStr.copy( nPos, nCount );
     268             :     }
     269           0 :     catch ( const Exception& )
     270             :     {
     271             :         SAL_WARN( "unotools.i18n", "titlecase: Exception caught!" );
     272           0 :         return rStr.copy( nPos, nCount );
     273             :     }
     274             : }
     275             : 
     276     1940507 : OUString CharClass::uppercase( const OUString& rStr, sal_Int32 nPos, sal_Int32 nCount ) const
     277             : {
     278             :     try
     279             :     {
     280     1940507 :         if ( xCC.is() )
     281     1940507 :             return xCC->toUpper( rStr, nPos, nCount, getMyLocale() );
     282             :         else
     283           0 :             return rStr.copy( nPos, nCount );
     284             :     }
     285           0 :     catch ( const Exception& )
     286             :     {
     287             :         SAL_WARN( "unotools.i18n", "uppercase: Exception caught!" );
     288           0 :         return rStr.copy( nPos, nCount );
     289             :     }
     290             : }
     291             : 
     292    11850215 : OUString CharClass::lowercase( const OUString& rStr, sal_Int32 nPos, sal_Int32 nCount ) const
     293             : {
     294             :     try
     295             :     {
     296    11850215 :         if ( xCC.is() )
     297    11850215 :             return xCC->toLower( rStr, nPos, nCount, getMyLocale() );
     298             :         else
     299           0 :             return rStr.copy( nPos, nCount );
     300             :     }
     301           0 :     catch ( const Exception& )
     302             :     {
     303             :         SAL_WARN( "unotools.i18n", "lowercase: Exception caught!" );
     304           0 :         return rStr.copy( nPos, nCount );
     305             :     }
     306             : }
     307             : 
     308       28953 : sal_Int16 CharClass::getType( const OUString& rStr, sal_Int32 nPos ) const
     309             : {
     310             :     try
     311             :     {
     312       28953 :         if ( xCC.is() )
     313       28953 :             return xCC->getType( rStr, nPos );
     314             :         else
     315           0 :             return 0;
     316             :     }
     317           0 :     catch ( const Exception& )
     318             :     {
     319             :         SAL_WARN( "unotools.i18n", "getType: Exception caught!" );
     320           0 :         return 0;
     321             :     }
     322             : }
     323             : 
     324       17322 : sal_Int16 CharClass::getCharacterDirection( const OUString& rStr, sal_Int32 nPos ) const
     325             : {
     326             :     try
     327             :     {
     328       17322 :         if ( xCC.is() )
     329       17322 :             return xCC->getCharacterDirection( rStr, nPos );
     330             :         else
     331           0 :             return 0;
     332             :     }
     333           0 :     catch ( const Exception& )
     334             :     {
     335             :         SAL_WARN( "unotools.i18n", "getCharacterDirection: Exception caught!" );
     336           0 :         return 0;
     337             :     }
     338             : }
     339             : 
     340          18 : sal_Int16 CharClass::getScript( const OUString& rStr, sal_Int32 nPos ) const
     341             : {
     342             :     try
     343             :     {
     344          18 :         if ( xCC.is() )
     345          18 :             return xCC->getScript( rStr, nPos );
     346             :         else
     347           0 :             return 0;
     348             :     }
     349           0 :     catch ( const Exception& )
     350             :     {
     351             :         SAL_WARN( "unotools.i18n", "getScript: Exception caught!" );
     352           0 :         return 0;
     353             :     }
     354             : }
     355             : 
     356   748112805 : sal_Int32 CharClass::getCharacterType( const OUString& rStr, sal_Int32 nPos ) const
     357             : {
     358             :     try
     359             :     {
     360   748112805 :         if ( xCC.is() )
     361   748112805 :             return xCC->getCharacterType( rStr, nPos, getMyLocale() );
     362             :         else
     363           0 :             return 0;
     364             :     }
     365           0 :     catch ( const Exception& )
     366             :     {
     367             :         SAL_WARN( "unotools.i18n", "getCharacterType: Exception caught!" );
     368           0 :         return 0;
     369             :     }
     370             : }
     371             : 
     372           0 : sal_Int32 CharClass::getStringType( const OUString& rStr, sal_Int32 nPos, sal_Int32 nCount ) const
     373             : {
     374             :     try
     375             :     {
     376           0 :         if ( xCC.is() )
     377           0 :             return xCC->getStringType( rStr, nPos, nCount, getMyLocale() );
     378             :         else
     379           0 :             return 0;
     380             :     }
     381           0 :     catch ( const Exception& )
     382             :     {
     383             :         SAL_WARN( "unotools.i18n", "getStringType: Exception caught!" );
     384           0 :         return 0;
     385             :     }
     386             : }
     387             : 
     388       18417 : ::com::sun::star::i18n::ParseResult CharClass::parseAnyToken(
     389             :             const OUString& rStr,
     390             :             sal_Int32 nPos,
     391             :             sal_Int32 nStartCharFlags,
     392             :             const OUString& userDefinedCharactersStart,
     393             :             sal_Int32 nContCharFlags,
     394             :             const OUString& userDefinedCharactersCont ) const
     395             : {
     396             :     try
     397             :     {
     398       18417 :         if ( xCC.is() )
     399       36834 :             return xCC->parseAnyToken( rStr, nPos, getMyLocale(),
     400             :                 nStartCharFlags, userDefinedCharactersStart,
     401       36834 :                 nContCharFlags, userDefinedCharactersCont );
     402             :         else
     403           0 :             return ParseResult();
     404             :     }
     405           0 :     catch ( const Exception& e )
     406             :     {
     407             :         SAL_WARN( "unotools.i18n", "parseAnyToken: Exception caught " << e.Message );
     408           0 :         return ParseResult();
     409             :     }
     410             : }
     411             : 
     412       49133 : ::com::sun::star::i18n::ParseResult CharClass::parsePredefinedToken(
     413             :             sal_Int32 nTokenType,
     414             :             const OUString& rStr,
     415             :             sal_Int32 nPos,
     416             :             sal_Int32 nStartCharFlags,
     417             :             const OUString& userDefinedCharactersStart,
     418             :             sal_Int32 nContCharFlags,
     419             :             const OUString& userDefinedCharactersCont ) const
     420             : {
     421             :     try
     422             :     {
     423       49133 :         if ( xCC.is() )
     424       98266 :             return xCC->parsePredefinedToken( nTokenType, rStr, nPos, getMyLocale(),
     425             :                 nStartCharFlags, userDefinedCharactersStart,
     426       98266 :                 nContCharFlags, userDefinedCharactersCont );
     427             :         else
     428           0 :             return ParseResult();
     429             :     }
     430           0 :     catch ( const Exception& e )
     431             :     {
     432             :         SAL_WARN( "unotools.i18n", "parsePredefinedToken: Exception caught " << e.Message );
     433           0 :         return ParseResult();
     434             :     }
     435             : }
     436             : 
     437             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11