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