| /************************************************************** | |
| * | |
| * Licensed to the Apache Software Foundation (ASF) under one | |
| * or more contributor license agreements. See the NOTICE file | |
| * distributed with this work for additional information | |
| * regarding copyright ownership. The ASF licenses this file | |
| * to you under the Apache License, Version 2.0 (the | |
| * "License"); you may not use this file except in compliance | |
| * with the License. You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| * | |
| *************************************************************/ | |
| // MARKER(update_precomp.py): autogen include statement, do not remove | |
| #include "precompiled_forms.hxx" | |
| #include "convert.hxx" | |
| #include "unohelper.hxx" | |
| #include <memory> | |
| #include <algorithm> | |
| #include <functional> | |
| #include <rtl/math.hxx> | |
| #include <rtl/ustrbuf.hxx> | |
| #include <tools/date.hxx> | |
| #include <com/sun/star/uno/Type.hxx> | |
| #include <com/sun/star/xsd/WhiteSpaceTreatment.hpp> | |
| #include <com/sun/star/util/Date.hpp> | |
| #include <com/sun/star/util/DateTime.hpp> | |
| #include <com/sun/star/util/Time.hpp> | |
| using xforms::Convert; | |
| using ::rtl::OUString; | |
| using ::rtl::OUStringBuffer; | |
| using com::sun::star::uno::Any; | |
| using com::sun::star::uno::makeAny; | |
| using com::sun::star::util::Time; | |
| using namespace std; | |
| typedef com::sun::star::util::Date UNODate; | |
| typedef com::sun::star::util::Time UNOTime; | |
| typedef com::sun::star::util::DateTime UNODateTime; | |
| Convert::Convert() | |
| : maMap() | |
| { | |
| init(); | |
| } | |
| #define ADD_ENTRY(XCONVERT,TYPE) XCONVERT->maMap[ getCppuType( static_cast<TYPE*>( NULL ) ) ] = Convert_t( &lcl_toXSD_##TYPE, &lcl_toAny_##TYPE ) | |
| namespace | |
| { | |
| // ======================================================================== | |
| struct StringToken | |
| { | |
| private: | |
| ::rtl::OUString m_sString; | |
| sal_Int32 m_nTokenStart; | |
| sal_Int32 m_nTokenEnd; | |
| public: | |
| StringToken() : m_sString(), m_nTokenStart( 0 ), m_nTokenEnd( 0 ) { } | |
| StringToken( const ::rtl::OUString& _rString, sal_Int32 _nTokenStart, sal_Int32 _nTokenEnd ); | |
| StringToken( const StringToken& ); | |
| StringToken& operator=( const StringToken& ); | |
| inline bool isEmpty() const { return m_nTokenEnd <= m_nTokenStart; } | |
| inline sal_Int32 getLength() const { return isEmpty() ? 0 : m_nTokenEnd - m_nTokenStart - 1; } | |
| inline const sal_Unicode* begin() const { return m_sString.getStr() + m_nTokenStart; } | |
| inline const sal_Unicode* end() const { return m_sString.getStr() + m_nTokenEnd; } | |
| bool toInt32( sal_Int32& _rValue ) const; | |
| }; | |
| // ------------------------------------------------------------------------ | |
| StringToken::StringToken( const ::rtl::OUString& _rString, sal_Int32 _nTokenStart, sal_Int32 _nTokenEnd ) | |
| :m_sString( _rString ) | |
| ,m_nTokenStart( _nTokenStart ) | |
| ,m_nTokenEnd( _nTokenEnd ) | |
| { | |
| OSL_ENSURE( ( m_nTokenStart >= 0 ) && ( m_nTokenStart <= m_sString.getLength() ), "StringToken::StringToken: invalid token start!" ); | |
| OSL_ENSURE( ( m_nTokenEnd >= 0 ) && ( m_nTokenEnd <= m_sString.getLength() ), "StringToken::StringToken: invalid token end!" ); | |
| } | |
| // ------------------------------------------------------------------------ | |
| StringToken::StringToken( const StringToken& _rRHS ) | |
| { | |
| *this = _rRHS; | |
| } | |
| // ------------------------------------------------------------------------ | |
| StringToken& StringToken::operator=( const StringToken& _rRHS ) | |
| { | |
| if ( this == &_rRHS ) | |
| return *this; | |
| m_sString = _rRHS.m_sString; | |
| m_nTokenStart = _rRHS.m_nTokenStart; | |
| m_nTokenEnd = _rRHS.m_nTokenEnd; | |
| return *this; | |
| } | |
| // ------------------------------------------------------------------------ | |
| bool StringToken::toInt32( sal_Int32& _rValue ) const | |
| { | |
| if ( isEmpty() ) | |
| return false; | |
| _rValue = 0; | |
| const sal_Unicode* pStr = begin(); | |
| while ( pStr < end() ) | |
| { | |
| if ( ( *pStr < '0' ) || ( *pStr > '9' ) ) | |
| return false; | |
| _rValue *= 10; | |
| _rValue += ( *pStr - '0' ); | |
| ++pStr; | |
| } | |
| return true; | |
| } | |
| // ======================================================================== | |
| class StringTokenizer | |
| { | |
| private: | |
| ::rtl::OUString m_sString; | |
| const sal_Unicode m_nTokenSeparator; | |
| sal_Int32 m_nTokenStart; | |
| public: | |
| /** constructs a tokenizer | |
| @param _rString the string to tokenize | |
| @param _nTokenSeparator the token value. May be 0, in this case the tokenizer | |
| will recognize exactly one token, being the whole string. | |
| This may make sense if you want to apply <type>StringToken</type> | |
| methods to a whole string. | |
| */ | |
| StringTokenizer( const ::rtl::OUString& _rString, sal_Unicode _nTokenSeparator = ';' ); | |
| /// resets the tokenizer to the beginning of the string | |
| void reset(); | |
| /// determines whether there is a next token | |
| bool hasNextToken() const; | |
| /// retrieves the next token | |
| StringToken | |
| getNextToken(); | |
| }; | |
| // ------------------------------------------------------------------------ | |
| StringTokenizer::StringTokenizer( const ::rtl::OUString& _rString, sal_Unicode _nTokenSeparator ) | |
| :m_sString( _rString ) | |
| ,m_nTokenSeparator( _nTokenSeparator ) | |
| { | |
| reset(); | |
| } | |
| // ------------------------------------------------------------------------ | |
| void StringTokenizer::reset() | |
| { | |
| m_nTokenStart = 0; | |
| } | |
| // ------------------------------------------------------------------------ | |
| bool StringTokenizer::hasNextToken() const | |
| { | |
| return ( m_nTokenStart < m_sString.getLength() ); | |
| } | |
| // ------------------------------------------------------------------------ | |
| StringToken StringTokenizer::getNextToken() | |
| { | |
| OSL_PRECOND( hasNextToken(), "StringTokenizer::getNextToken: there is no next token!" ); | |
| if ( !hasNextToken() ) | |
| return StringToken(); | |
| // determine the end of the current token | |
| sal_Int32 nTokenEnd = m_nTokenSeparator ? m_sString.indexOf( m_nTokenSeparator, m_nTokenStart ) : m_sString.getLength(); | |
| bool bLastToken = !m_nTokenSeparator || ( nTokenEnd == -1 ); | |
| // construct a new token | |
| StringToken aToken( m_sString, m_nTokenStart, bLastToken ? m_sString.getLength() : nTokenEnd ); | |
| // advance | |
| m_nTokenStart = bLastToken ? m_sString.getLength() : nTokenEnd + 1; | |
| // outta here | |
| return aToken; | |
| } | |
| // ======================================================================== | |
| // ------------------------------------------------------------------------ | |
| OUString lcl_toXSD_OUString( const Any& rAny ) | |
| { OUString sStr; rAny >>= sStr; return sStr; } | |
| // ------------------------------------------------------------------------ | |
| Any lcl_toAny_OUString( const OUString& rStr ) | |
| { Any aAny; aAny <<= rStr; return aAny; } | |
| // ------------------------------------------------------------------------ | |
| OUString lcl_toXSD_bool( const Any& rAny ) | |
| { bool b = false; rAny >>= b; return b ? OUSTRING("true") : OUSTRING("false"); } | |
| // ------------------------------------------------------------------------ | |
| Any lcl_toAny_bool( const OUString& rStr ) | |
| { | |
| bool b = ( rStr == OUSTRING("true") || rStr == OUSTRING("1") ); | |
| return makeAny( b ); | |
| } | |
| // ------------------------------------------------------------------------ | |
| OUString lcl_toXSD_double( const Any& rAny ) | |
| { | |
| double f = 0.0; | |
| rAny >>= f; | |
| return rtl::math::isFinite( f ) | |
| ? rtl::math::doubleToUString( f, rtl_math_StringFormat_Automatic, | |
| rtl_math_DecimalPlaces_Max, '.', | |
| sal_True ) | |
| : OUString(); | |
| } | |
| // ------------------------------------------------------------------------ | |
| Any lcl_toAny_double( const OUString& rString ) | |
| { | |
| rtl_math_ConversionStatus eStatus; | |
| double f = rtl::math::stringToDouble( | |
| rString, sal_Unicode('.'), sal_Unicode(','), &eStatus, NULL ); | |
| return ( eStatus == rtl_math_ConversionStatus_Ok ) ? makeAny( f ) : Any(); | |
| } | |
| // ------------------------------------------------------------------------ | |
| void lcl_appendInt32ToBuffer( const sal_Int32 _nValue, ::rtl::OUStringBuffer& _rBuffer, sal_Int16 _nMinDigits ) | |
| { | |
| if ( ( _nMinDigits >= 4 ) && ( _nValue < 1000 ) ) | |
| _rBuffer.append( (sal_Unicode)'0' ); | |
| if ( ( _nMinDigits >= 3 ) && ( _nValue < 100 ) ) | |
| _rBuffer.append( (sal_Unicode)'0' ); | |
| if ( ( _nMinDigits >= 2 ) && ( _nValue < 10 ) ) | |
| _rBuffer.append( (sal_Unicode)'0' ); | |
| _rBuffer.append( _nValue ); | |
| } | |
| // ------------------------------------------------------------------------ | |
| OUString lcl_toXSD_UNODate_typed( const UNODate& rDate ) | |
| { | |
| ::rtl::OUStringBuffer sInfo; | |
| lcl_appendInt32ToBuffer( rDate.Year, sInfo, 4 ); | |
| sInfo.appendAscii( "-" ); | |
| lcl_appendInt32ToBuffer( rDate.Month, sInfo, 2 ); | |
| sInfo.appendAscii( "-" ); | |
| lcl_appendInt32ToBuffer( rDate.Day, sInfo, 2 ); | |
| return sInfo.makeStringAndClear(); | |
| } | |
| // ------------------------------------------------------------------------ | |
| OUString lcl_toXSD_UNODate( const Any& rAny ) | |
| { | |
| UNODate aDate; | |
| OSL_VERIFY( rAny >>= aDate ); | |
| return lcl_toXSD_UNODate_typed( aDate ); | |
| } | |
| // ------------------------------------------------------------------------ | |
| UNODate lcl_toUNODate( const OUString& rString ) | |
| { | |
| bool bWellformed = true; | |
| UNODate aDate( 1, 1, 1900 ); | |
| sal_Int32 nToken = 0; | |
| StringTokenizer aTokenizer( rString, '-' ); | |
| while ( aTokenizer.hasNextToken() ) | |
| { | |
| sal_Int32 nTokenValue = 0; | |
| if ( !aTokenizer.getNextToken().toInt32( nTokenValue ) ) | |
| { | |
| bWellformed = false; | |
| break; | |
| } | |
| if ( nToken == 0 ) | |
| aDate.Year = (sal_uInt16)nTokenValue; | |
| else if ( nToken == 1 ) | |
| aDate.Month = (sal_uInt16)nTokenValue; | |
| else if ( nToken == 2 ) | |
| aDate.Day = (sal_uInt16)nTokenValue; | |
| else | |
| { | |
| bWellformed = false; | |
| break; | |
| } | |
| ++nToken; | |
| } | |
| // sanity checks | |
| if ( ( aDate.Year > 9999 ) || ( aDate.Month < 1 ) || ( aDate.Month > 12 ) || ( aDate.Day < 1 ) || ( aDate.Day > 31 ) ) | |
| bWellformed = false; | |
| else | |
| { | |
| ::Date aDateCheck( 1, aDate.Month, aDate.Year ); | |
| if ( aDate.Day > aDateCheck.GetDaysInMonth() ) | |
| bWellformed = false; | |
| } | |
| // all okay? | |
| if ( !bWellformed ) | |
| return UNODate( 1, 1, 1900 ); | |
| return aDate; | |
| } | |
| // ------------------------------------------------------------------------ | |
| Any lcl_toAny_UNODate( const OUString& rString ) | |
| { | |
| return makeAny( lcl_toUNODate( rString ) ); | |
| } | |
| // ------------------------------------------------------------------------ | |
| OUString lcl_toXSD_UNOTime_typed( const UNOTime& rTime ) | |
| { | |
| ::rtl::OUStringBuffer sInfo; | |
| lcl_appendInt32ToBuffer( rTime.Hours, sInfo, 2 ); | |
| sInfo.appendAscii( ":" ); | |
| lcl_appendInt32ToBuffer( rTime.Minutes, sInfo, 2 ); | |
| sInfo.appendAscii( ":" ); | |
| lcl_appendInt32ToBuffer( rTime.Seconds, sInfo, 2 ); | |
| if ( rTime.HundredthSeconds ) | |
| { | |
| sInfo.appendAscii( "." ); | |
| lcl_appendInt32ToBuffer( rTime.HundredthSeconds, sInfo, 2 ); | |
| } | |
| return sInfo.makeStringAndClear(); | |
| } | |
| // ------------------------------------------------------------------------ | |
| OUString lcl_toXSD_UNOTime( const Any& rAny ) | |
| { | |
| UNOTime aTime; | |
| OSL_VERIFY( rAny >>= aTime ); | |
| return lcl_toXSD_UNOTime_typed( aTime ); | |
| } | |
| // ------------------------------------------------------------------------ | |
| UNOTime lcl_toUNOTime( const OUString& rString ) | |
| { | |
| bool bWellformed = true; | |
| UNOTime aTime( 0, 0, 0, 0 ); | |
| ::rtl::OUString sString( rString ); | |
| // see if there's a decimal separator for the seconds, | |
| // and if so, handle it separately | |
| sal_Int32 nDecimalSepPos = rString.indexOf( '.' ); | |
| if ( nDecimalSepPos == -1 ) | |
| // ISO 8601 allows for both a comma and a dot | |
| nDecimalSepPos = rString.indexOf( ',' ); | |
| if ( nDecimalSepPos != -1 ) | |
| { | |
| // handle fractional seconds | |
| ::rtl::OUString sFractional = sString.copy( nDecimalSepPos + 1 ); | |
| if ( sFractional.getLength() > 2 ) | |
| // our precision is HundrethSeconds - it's all a css.util.Time can hold | |
| sFractional = sFractional.copy( 0, 2 ); | |
| sal_Int32 nFractional = 0; | |
| if ( sFractional.getLength() ) | |
| { | |
| if ( StringTokenizer( sFractional, 0 ).getNextToken().toInt32( nFractional ) ) | |
| { | |
| aTime.HundredthSeconds = (sal_uInt16)nFractional; | |
| if ( nFractional < 10 ) | |
| aTime.HundredthSeconds *= 10; | |
| } | |
| else | |
| bWellformed = false; | |
| } | |
| // strip the fraction before further processing | |
| sString = sString.copy( 0, nDecimalSepPos ); | |
| } | |
| // split into the tokens which are separated by colon | |
| sal_Int32 nToken = 0; | |
| StringTokenizer aTokenizer( sString, ':' ); | |
| while ( aTokenizer.hasNextToken() ) | |
| { | |
| sal_Int32 nTokenValue = 0; | |
| if ( !aTokenizer.getNextToken().toInt32( nTokenValue ) ) | |
| { | |
| bWellformed = false; | |
| break; | |
| } | |
| if ( nToken == 0 ) | |
| aTime.Hours = (sal_uInt16)nTokenValue; | |
| else if ( nToken == 1 ) | |
| aTime.Minutes = (sal_uInt16)nTokenValue; | |
| else if ( nToken == 2 ) | |
| aTime.Seconds = (sal_uInt16)nTokenValue; | |
| else | |
| { | |
| bWellformed = false; | |
| break; | |
| } | |
| ++nToken; | |
| } | |
| // sanity checks | |
| // note that Seconds == 60 denotes leap seconds. Normally, they're not allowed everywhere, | |
| // but we accept them all the time for simplicity reasons | |
| if ( ( aTime.Hours > 24 ) | |
| || ( aTime.Minutes > 59 ) | |
| || ( aTime.Seconds > 60 ) | |
| ) | |
| bWellformed = false; | |
| if ( bWellformed | |
| && ( aTime.Hours == 24 ) | |
| && ( ( aTime.Minutes != 0 ) | |
| || ( aTime.Seconds != 0 ) | |
| || ( aTime.HundredthSeconds != 0 ) | |
| ) | |
| ) | |
| bWellformed = false; | |
| // all okay? | |
| if ( !bWellformed ) | |
| return UNOTime( 0, 0, 0, 0 ); | |
| return aTime; | |
| } | |
| // ------------------------------------------------------------------------ | |
| Any lcl_toAny_UNOTime( const OUString& rString ) | |
| { | |
| return makeAny( lcl_toUNOTime( rString ) ); | |
| } | |
| // ------------------------------------------------------------------------ | |
| OUString lcl_toXSD_UNODateTime( const Any& rAny ) | |
| { | |
| UNODateTime aDateTime; | |
| OSL_VERIFY( rAny >>= aDateTime ); | |
| UNODate aDate( aDateTime.Day, aDateTime.Month, aDateTime.Year ); | |
| ::rtl::OUString sDate = lcl_toXSD_UNODate_typed( aDate ); | |
| UNOTime aTime( aDateTime.HundredthSeconds, aDateTime.Seconds, aDateTime.Minutes, aDateTime.Hours ); | |
| ::rtl::OUString sTime = lcl_toXSD_UNOTime_typed( aTime ); | |
| ::rtl::OUStringBuffer sInfo; | |
| sInfo.append( sDate ); | |
| sInfo.append( (sal_Unicode) 'T' ); | |
| sInfo.append( sTime ); | |
| return sInfo.makeStringAndClear(); | |
| } | |
| // ------------------------------------------------------------------------ | |
| Any lcl_toAny_UNODateTime( const OUString& rString ) | |
| { | |
| // separate the date from the time part | |
| sal_Int32 nDateTimeSep = rString.indexOf( 'T' ); | |
| if ( nDateTimeSep == -1 ) | |
| nDateTimeSep = rString.indexOf( 't' ); | |
| UNODate aDate; | |
| UNOTime aTime; | |
| if ( nDateTimeSep == -1 ) | |
| { // no time part | |
| aDate = lcl_toUNODate( rString ); | |
| aTime = UNOTime( 0, 0, 0, 0 ); | |
| } | |
| else | |
| { | |
| aDate = lcl_toUNODate( rString.copy( 0, nDateTimeSep ) ); | |
| aTime = lcl_toUNOTime( rString.copy( nDateTimeSep + 1 ) ); | |
| } | |
| UNODateTime aDateTime( | |
| aTime.HundredthSeconds, aTime.Seconds, aTime.Minutes, aTime.Hours, | |
| aDate.Day, aDate.Month, aDate.Year | |
| ); | |
| return makeAny( aDateTime ); | |
| } | |
| } | |
| // ============================================================================ | |
| void Convert::init() | |
| { | |
| ADD_ENTRY( this, OUString ); | |
| ADD_ENTRY( this, bool ); | |
| ADD_ENTRY( this, double ); | |
| ADD_ENTRY( this, UNODate ); | |
| ADD_ENTRY( this, UNOTime ); | |
| ADD_ENTRY( this, UNODateTime ); | |
| } | |
| Convert& Convert::get() | |
| { | |
| // create our Singleton instance on demand | |
| static Convert* pConvert = NULL; | |
| if( pConvert == NULL ) | |
| pConvert = new Convert(); | |
| OSL_ENSURE( pConvert != NULL, "no converter?" ); | |
| return *pConvert; | |
| } | |
| bool Convert::hasType( const Type_t& rType ) | |
| { | |
| return maMap.find( rType ) != maMap.end(); | |
| } | |
| Convert::Types_t Convert::getTypes() | |
| { | |
| Types_t aTypes( maMap.size() ); | |
| transform( maMap.begin(), maMap.end(), aTypes.getArray(), | |
| select1st<Map_t::value_type>() ); | |
| return aTypes; | |
| } | |
| rtl::OUString Convert::toXSD( const Any_t& rAny ) | |
| { | |
| Map_t::iterator aIter = maMap.find( rAny.getValueType() ); | |
| return aIter != maMap.end() ? aIter->second.first( rAny ) : OUString(); | |
| } | |
| Convert::Any_t Convert::toAny( const rtl::OUString& rValue, | |
| const Type_t& rType ) | |
| { | |
| Map_t::iterator aIter = maMap.find( rType ); | |
| return aIter != maMap.end() ? aIter->second.second( rValue ) : Any_t(); | |
| } | |
| //------------------------------------------------------------------------ | |
| ::rtl::OUString Convert::convertWhitespace( const ::rtl::OUString& _rString, sal_Int16 _nWhitespaceTreatment ) | |
| { | |
| ::rtl::OUString sConverted; | |
| switch( _nWhitespaceTreatment ) | |
| { | |
| default: | |
| OSL_ENSURE( sal_False, "Convert::convertWhitespace: invalid whitespace treatment constant!" ); | |
| // NO break | |
| case com::sun::star::xsd::WhiteSpaceTreatment::Preserve: | |
| sConverted = _rString; | |
| break; | |
| case com::sun::star::xsd::WhiteSpaceTreatment::Replace: | |
| sConverted = replaceWhitespace( _rString ); | |
| break; | |
| case com::sun::star::xsd::WhiteSpaceTreatment::Collapse: | |
| sConverted = collapseWhitespace( _rString ); | |
| break; | |
| } | |
| return sConverted; | |
| } | |
| //------------------------------------------------------------------------ | |
| ::rtl::OUString Convert::replaceWhitespace( const ::rtl::OUString& _rString ) | |
| { | |
| OUStringBuffer aBuffer( _rString ); | |
| sal_Int32 nLength = aBuffer.getLength(); | |
| const sal_Unicode* pBuffer = aBuffer.getStr(); | |
| for( sal_Int32 i = 0; i < nLength; i++ ) | |
| { | |
| sal_Unicode c = pBuffer[i]; | |
| if( c == sal_Unicode(0x08) || | |
| c == sal_Unicode(0x0A) || | |
| c == sal_Unicode(0x0D) ) | |
| aBuffer.setCharAt( i, sal_Unicode(0x20) ); | |
| } | |
| return aBuffer.makeStringAndClear(); | |
| } | |
| //------------------------------------------------------------------------ | |
| ::rtl::OUString Convert::collapseWhitespace( const ::rtl::OUString& _rString ) | |
| { | |
| sal_Int32 nLength = _rString.getLength(); | |
| OUStringBuffer aBuffer( nLength ); | |
| const sal_Unicode* pStr = _rString.getStr(); | |
| bool bStrip = true; | |
| for( sal_Int32 i = 0; i < nLength; i++ ) | |
| { | |
| sal_Unicode c = pStr[i]; | |
| if( c == sal_Unicode(0x08) || | |
| c == sal_Unicode(0x0A) || | |
| c == sal_Unicode(0x0D) || | |
| c == sal_Unicode(0x20) ) | |
| { | |
| if( ! bStrip ) | |
| { | |
| aBuffer.append( sal_Unicode(0x20) ); | |
| bStrip = true; | |
| } | |
| } | |
| else | |
| { | |
| bStrip = false; | |
| aBuffer.append( c ); | |
| } | |
| } | |
| if( aBuffer[ aBuffer.getLength() - 1 ] == sal_Unicode( 0x20 ) ) | |
| aBuffer.setLength( aBuffer.getLength() - 1 ); | |
| return aBuffer.makeStringAndClear(); | |
| } |