LCOV - code coverage report
Current view: top level - forms/source/xforms - convert.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 155 0.0 %
Date: 2014-04-14 Functions: 0 25 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             : 
      21             : #include "convert.hxx"
      22             : 
      23             : #include "unohelper.hxx"
      24             : #include <algorithm>
      25             : #include <functional>
      26             : #include <o3tl/compat_functional.hxx>
      27             : #include <rtl/math.hxx>
      28             : #include <rtl/ustrbuf.hxx>
      29             : #include <tools/date.hxx>
      30             : #include <com/sun/star/uno/Type.hxx>
      31             : #include <com/sun/star/xsd/WhiteSpaceTreatment.hpp>
      32             : #include <com/sun/star/util/Date.hpp>
      33             : #include <com/sun/star/util/DateTime.hpp>
      34             : #include <com/sun/star/util/Time.hpp>
      35             : #include <unotools/datetime.hxx>
      36             : 
      37             : using xforms::Convert;
      38             : using com::sun::star::uno::Any;
      39             : using com::sun::star::uno::makeAny;
      40             : using namespace std;
      41             : using namespace o3tl;
      42             : using namespace utl;
      43             : 
      44             : typedef com::sun::star::util::Date UNODate;
      45             : typedef com::sun::star::util::Time UNOTime;
      46             : typedef com::sun::star::util::DateTime UNODateTime;
      47             : 
      48           0 : Convert::Convert()
      49           0 :     : maMap()
      50             : {
      51           0 :     init();
      52           0 : }
      53             : 
      54             : #define ADD_ENTRY(XCONVERT,TYPE) XCONVERT->maMap[ getCppuType( static_cast<TYPE*>( NULL ) ) ] = Convert_t( &lcl_toXSD_##TYPE, &lcl_toAny_##TYPE )
      55             : 
      56             : namespace
      57             : {
      58             : 
      59           0 :     OUString lcl_toXSD_OUString( const Any& rAny )
      60           0 :     { OUString sStr; rAny >>= sStr; return sStr; }
      61             : 
      62             : 
      63           0 :     Any lcl_toAny_OUString( const OUString& rStr )
      64           0 :     { Any aAny; aAny <<= rStr; return aAny; }
      65             : 
      66             : 
      67           0 :     OUString lcl_toXSD_bool( const Any& rAny )
      68           0 :     { bool b = false; rAny >>= b; return b ? OUString("true") : OUString("false"); }
      69             : 
      70             : 
      71           0 :     Any lcl_toAny_bool( const OUString& rStr )
      72             :     {
      73           0 :         bool b = ( rStr == "true"  ||  rStr == "1" );
      74           0 :         return makeAny( b );
      75             :     }
      76             : 
      77             : 
      78           0 :     OUString lcl_toXSD_double( const Any& rAny )
      79             :     {
      80           0 :         double f = 0.0;
      81           0 :         rAny >>= f;
      82             : 
      83           0 :         return rtl::math::isFinite( f )
      84             :             ? rtl::math::doubleToUString( f, rtl_math_StringFormat_Automatic,
      85             :                                         rtl_math_DecimalPlaces_Max, '.',
      86             :                                         true )
      87           0 :             : OUString();
      88             :     }
      89             : 
      90             : 
      91           0 :     Any lcl_toAny_double( const OUString& rString )
      92             :     {
      93             :         rtl_math_ConversionStatus eStatus;
      94             :         double f = rtl::math::stringToDouble(
      95           0 :             rString, '.', ',', &eStatus, NULL );
      96           0 :         return ( eStatus == rtl_math_ConversionStatus_Ok ) ? makeAny( f ) : Any();
      97             :     }
      98             : 
      99             : 
     100           0 :     void lcl_appendInt32ToBuffer( const sal_Int32 _nValue, OUStringBuffer& _rBuffer, sal_Int16 _nMinDigits )
     101             :     {
     102           0 :         if ( ( _nMinDigits >= 4 ) && ( _nValue < 1000 ) )
     103           0 :             _rBuffer.append( '0' );
     104           0 :         if ( ( _nMinDigits >= 3 ) && ( _nValue < 100 ) )
     105           0 :             _rBuffer.append( '0' );
     106           0 :         if ( ( _nMinDigits >= 2 ) && ( _nValue < 10 ) )
     107           0 :             _rBuffer.append( '0' );
     108           0 :         _rBuffer.append( _nValue );
     109           0 :     }
     110             : 
     111             : 
     112           0 :     OUString lcl_toXSD_UNODate_typed( const UNODate& rDate )
     113             :     {
     114             : 
     115           0 :         OUStringBuffer sInfo;
     116           0 :         lcl_appendInt32ToBuffer( rDate.Year, sInfo, 4 );
     117           0 :         sInfo.appendAscii( "-" );
     118           0 :         lcl_appendInt32ToBuffer( rDate.Month, sInfo, 2 );
     119           0 :         sInfo.appendAscii( "-" );
     120           0 :         lcl_appendInt32ToBuffer( rDate.Day, sInfo, 2 );
     121             : 
     122           0 :         return sInfo.makeStringAndClear();
     123             :     }
     124             : 
     125             : 
     126           0 :     OUString lcl_toXSD_UNODate( const Any& rAny )
     127             :     {
     128           0 :         UNODate aDate;
     129           0 :         OSL_VERIFY( rAny >>= aDate );
     130           0 :         return lcl_toXSD_UNODate_typed( aDate );
     131             :     }
     132             : 
     133             : 
     134           0 :     UNODate lcl_toUNODate( const OUString& rString )
     135             :     {
     136           0 :         UNODate aDate( 1, 1, 1900 );
     137             : 
     138           0 :         bool bWellformed = ISO8601parseDate(rString, aDate);
     139             : 
     140             :         // sanity checks
     141           0 :         if ( ( aDate.Year > 9999 ) || ( aDate.Month < 1 ) || ( aDate.Month > 12 ) || ( aDate.Day < 1 ) || ( aDate.Day > 31 ) )
     142           0 :             bWellformed = false;
     143             :         else
     144             :         {
     145           0 :             ::Date aDateCheck( 1, aDate.Month, aDate.Year );
     146           0 :             if ( aDate.Day > aDateCheck.GetDaysInMonth() )
     147           0 :                 bWellformed = false;
     148             :         }
     149             : 
     150             :         // all okay?
     151           0 :         if ( !bWellformed )
     152           0 :             return UNODate( 1, 1, 1900 );
     153             : 
     154           0 :         return aDate;
     155             :     }
     156             : 
     157             : 
     158           0 :     Any lcl_toAny_UNODate( const OUString& rString )
     159             :     {
     160           0 :         return makeAny( lcl_toUNODate( rString ) );
     161             :     }
     162             : 
     163             : 
     164           0 :     OUString lcl_toXSD_UNOTime_typed( const UNOTime& rTime )
     165             :     {
     166             : 
     167           0 :         OUStringBuffer sInfo;
     168           0 :         lcl_appendInt32ToBuffer( rTime.Hours, sInfo, 2 );
     169           0 :         sInfo.appendAscii( ":" );
     170           0 :         lcl_appendInt32ToBuffer( rTime.Minutes, sInfo, 2 );
     171           0 :         sInfo.appendAscii( ":" );
     172           0 :         lcl_appendInt32ToBuffer( rTime.Seconds, sInfo, 2 );
     173           0 :         if ( rTime.NanoSeconds != 0 )
     174             :         {
     175             :             OSL_ENSURE(rTime.NanoSeconds < 1000000000,"NanoSeconds cannot be more than 999 999 999");
     176           0 :             sInfo.append('.');
     177           0 :             std::ostringstream ostr;
     178           0 :             ostr.fill('0');
     179           0 :             ostr.width(9);
     180           0 :             ostr << rTime.NanoSeconds;
     181           0 :             sInfo.append(OUString::createFromAscii(ostr.str().c_str()));
     182             :         }
     183             : 
     184           0 :         return sInfo.makeStringAndClear();
     185             :     }
     186             : 
     187             : 
     188           0 :     OUString lcl_toXSD_UNOTime( const Any& rAny )
     189             :     {
     190           0 :         UNOTime aTime;
     191           0 :         OSL_VERIFY( rAny >>= aTime );
     192           0 :         return lcl_toXSD_UNOTime_typed( aTime );
     193             :     }
     194             : 
     195             : 
     196           0 :     UNOTime lcl_toUNOTime( const OUString& rString )
     197             :     {
     198           0 :         UNOTime aTime;
     199             : 
     200           0 :         bool bWellformed = ISO8601parseTime(rString, aTime);
     201             : 
     202             :         // sanity checks
     203             :         // note that Seconds == 60 denotes leap seconds. Normally, they're not allowed everywhere,
     204             :         // but we accept them all the time for simplicity reasons
     205           0 :         if  (  ( aTime.Hours > 24 )
     206           0 :             || ( aTime.Minutes > 59 )
     207           0 :             || ( aTime.Seconds > 60 )
     208             :             )
     209           0 :             bWellformed = false;
     210             : 
     211           0 :         if  (   bWellformed
     212           0 :             &&  ( aTime.Hours == 24 )
     213           0 :             &&  (   ( aTime.Minutes != 0 )
     214           0 :                 ||  ( aTime.Seconds != 0 )
     215           0 :                 ||  ( aTime.NanoSeconds != 0 )
     216             :                 )
     217             :             )
     218           0 :             bWellformed = false;
     219             : 
     220             :         // all okay?
     221           0 :         if ( !bWellformed )
     222           0 :             return UNOTime();
     223             : 
     224           0 :         return aTime;
     225             :     }
     226             : 
     227             : 
     228           0 :     Any lcl_toAny_UNOTime( const OUString& rString )
     229             :     {
     230           0 :         return makeAny( lcl_toUNOTime( rString ) );
     231             :     }
     232             : 
     233             : 
     234           0 :     OUString lcl_toXSD_UNODateTime( const Any& rAny )
     235             :     {
     236           0 :         UNODateTime aDateTime;
     237           0 :         OSL_VERIFY( rAny >>= aDateTime );
     238             : 
     239           0 :         UNODate aDate( aDateTime.Day, aDateTime.Month, aDateTime.Year );
     240           0 :         OUString sDate = lcl_toXSD_UNODate_typed( aDate );
     241             : 
     242             :         UNOTime const aTime( aDateTime.NanoSeconds, aDateTime.Seconds,
     243           0 :                     aDateTime.Minutes, aDateTime.Hours, aDateTime.IsUTC);
     244           0 :         OUString sTime = lcl_toXSD_UNOTime_typed( aTime );
     245             : 
     246           0 :         OUString sRet = sDate + "T" + sTime;
     247           0 :         return sRet;
     248             :     }
     249             : 
     250             : 
     251           0 :     Any lcl_toAny_UNODateTime( const OUString& rString )
     252             :     {
     253             :         // separate the date from the time part
     254           0 :         sal_Int32 nDateTimeSep = rString.indexOf( 'T' );
     255           0 :         if ( nDateTimeSep == -1 )
     256           0 :             nDateTimeSep = rString.indexOf( 't' );
     257             : 
     258           0 :         UNODate aDate;
     259           0 :         UNOTime aTime;
     260           0 :         if ( nDateTimeSep == -1 )
     261             :         {   // no time part
     262           0 :             aDate = lcl_toUNODate( rString );
     263             :         }
     264             :         else
     265             :         {
     266           0 :             aDate = lcl_toUNODate( rString.copy( 0, nDateTimeSep ) );
     267           0 :             aTime = lcl_toUNOTime( rString.copy( nDateTimeSep + 1 ) );
     268             :         }
     269             :         UNODateTime aDateTime(
     270             :             aTime.NanoSeconds, aTime.Seconds, aTime.Minutes, aTime.Hours,
     271             :             aDate.Day, aDate.Month, aDate.Year, aTime.IsUTC
     272           0 :         );
     273           0 :         return makeAny( aDateTime );
     274             :     }
     275             : }
     276             : 
     277             : 
     278           0 : void Convert::init()
     279             : {
     280           0 :     ADD_ENTRY( this, OUString );
     281           0 :     ADD_ENTRY( this, bool );
     282           0 :     ADD_ENTRY( this, double );
     283           0 :     ADD_ENTRY( this, UNODate );
     284           0 :     ADD_ENTRY( this, UNOTime );
     285           0 :     ADD_ENTRY( this, UNODateTime );
     286           0 : }
     287             : 
     288             : 
     289           0 : Convert& Convert::get()
     290             : {
     291             :     // create our Singleton instance on demand
     292             :     static Convert* pConvert = NULL;
     293           0 :     if( pConvert == NULL )
     294           0 :         pConvert = new Convert();
     295             : 
     296             :     OSL_ENSURE( pConvert != NULL, "no converter?" );
     297           0 :     return *pConvert;
     298             : }
     299             : 
     300           0 : bool Convert::hasType( const Type_t& rType )
     301             : {
     302           0 :     return maMap.find( rType ) != maMap.end();
     303             : }
     304             : 
     305           0 : Convert::Types_t Convert::getTypes()
     306             : {
     307           0 :     Types_t aTypes( maMap.size() );
     308             :     transform( maMap.begin(), maMap.end(), aTypes.getArray(),
     309           0 :                o3tl::select1st<Map_t::value_type>() );
     310           0 :     return aTypes;
     311             : }
     312             : 
     313           0 : OUString Convert::toXSD( const Any_t& rAny )
     314             : {
     315           0 :     Map_t::iterator aIter = maMap.find( rAny.getValueType() );
     316           0 :     return aIter != maMap.end() ? aIter->second.first( rAny ) : OUString();
     317             : }
     318             : 
     319           0 : Convert::Any_t Convert::toAny( const OUString& rValue,
     320             :                                const Type_t& rType )
     321             : {
     322           0 :     Map_t::iterator aIter = maMap.find( rType );
     323           0 :     return aIter != maMap.end() ? aIter->second.second( rValue ) : Any_t();
     324             : }
     325             : 
     326             : 
     327           0 : OUString Convert::collapseWhitespace( const OUString& _rString )
     328             : {
     329           0 :     sal_Int32 nLength = _rString.getLength();
     330           0 :     OUStringBuffer aBuffer( nLength );
     331           0 :     const sal_Unicode* pStr = _rString.getStr();
     332           0 :     bool bStrip = true;
     333           0 :     for( sal_Int32 i = 0; i < nLength; i++ )
     334             :     {
     335           0 :         sal_Unicode c = pStr[i];
     336           0 :         if( c == sal_Unicode(0x08) ||
     337           0 :             c == sal_Unicode(0x0A) ||
     338           0 :             c == sal_Unicode(0x0D) ||
     339             :             c == sal_Unicode(0x20) )
     340             :         {
     341           0 :             if( ! bStrip )
     342             :             {
     343           0 :                 aBuffer.append( sal_Unicode(0x20) );
     344           0 :                 bStrip = true;
     345             :             }
     346             :         }
     347             :         else
     348             :         {
     349           0 :             bStrip = false;
     350           0 :             aBuffer.append( c );
     351             :         }
     352             :     }
     353           0 :     if( aBuffer[ aBuffer.getLength() - 1 ] == sal_Unicode( 0x20 ) )
     354           0 :         aBuffer.setLength( aBuffer.getLength() - 1 );
     355           0 :     return aBuffer.makeStringAndClear();
     356             : }
     357             : 
     358             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10