LCOV - code coverage report
Current view: top level - forms/source/xforms - datatypes.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 0 402 0.0 %
Date: 2015-06-13 12:38:46 Functions: 0 91 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 "datatypes.hxx"
      21             : #include "resourcehelper.hxx"
      22             : #include "property.hrc"
      23             : #include "convert.hxx"
      24             : 
      25             : #include <com/sun/star/xsd/WhiteSpaceTreatment.hpp>
      26             : #include <tools/datetime.hxx>
      27             : #include <rtl/math.hxx>
      28             : 
      29             : 
      30             : namespace xforms
      31             : {
      32             : 
      33             : 
      34             :     using ::com::sun::star::uno::Reference;
      35             :     using ::com::sun::star::uno::RuntimeException;
      36             :     using ::com::sun::star::uno::Any;
      37             :     using ::com::sun::star::uno::makeAny;
      38             :     using ::com::sun::star::uno::Type;
      39             :     using ::com::sun::star::uno::Sequence;
      40             :     using ::com::sun::star::uno::Exception;
      41             :     using ::com::sun::star::util::VetoException;
      42             :     using ::com::sun::star::util::Date;
      43             :     using ::com::sun::star::util::Time;
      44             :     using ::com::sun::star::util::DateTime;
      45             :     using ::com::sun::star::lang::IllegalArgumentException;
      46             :     using ::com::sun::star::lang::WrappedTargetException;
      47             :     using ::com::sun::star::beans::UnknownPropertyException;
      48             :     using ::com::sun::star::beans::PropertyVetoException;
      49             :     using ::com::sun::star::beans::XPropertyChangeListener;
      50             :     using ::com::sun::star::beans::XVetoableChangeListener;
      51             : 
      52             :     using ::com::sun::star::beans::PropertyAttribute::BOUND;
      53             :     using ::com::sun::star::beans::PropertyAttribute::READONLY;
      54             : 
      55             :     using namespace ::com::sun::star::xsd;
      56             :     using namespace ::frm;
      57             :     U_NAMESPACE_USE
      58             : 
      59           0 :     OXSDDataType::OXSDDataType( const OUString& _rName, sal_Int16 _nTypeClass )
      60             :         :OXSDDataType_PBase( m_aBHelper )
      61             :         ,m_bIsBasic( true )
      62             :         ,m_nTypeClass( _nTypeClass )
      63             :         ,m_sName( _rName )
      64             :         ,m_nWST( WhiteSpaceTreatment::Preserve )
      65           0 :         ,m_bPatternMatcherDirty( true )
      66             :     {
      67           0 :     }
      68             : 
      69             : 
      70           0 :     OXSDDataType::~OXSDDataType()
      71             :     {
      72           0 :     }
      73             : 
      74             : 
      75           0 :     void OXSDDataType::registerProperties()
      76             :     {
      77           0 :         registerProperty( PROPERTY_NAME,            PROPERTY_ID_NAME,           BOUND, &m_sName,    cppu::UnoType<decltype(m_sName)>::get() );
      78           0 :         registerProperty( PROPERTY_XSD_WHITESPACE,  PROPERTY_ID_XSD_WHITESPACE, BOUND, &m_nWST,     cppu::UnoType<cppu::UnoUnsignedShortType>::get() );
      79           0 :         registerProperty( PROPERTY_XSD_PATTERN,     PROPERTY_ID_XSD_PATTERN,    BOUND, &m_sPattern, cppu::UnoType<decltype(m_sPattern)>::get() );
      80             : 
      81           0 :         registerProperty( PROPERTY_XSD_IS_BASIC,    PROPERTY_ID_XSD_IS_BASIC,   READONLY, &m_bIsBasic,      cppu::UnoType<decltype(m_bIsBasic)>::get() );
      82           0 :         registerProperty( PROPERTY_XSD_TYPE_CLASS,  PROPERTY_ID_XSD_TYPE_CLASS, READONLY, &m_nTypeClass,    cppu::UnoType<decltype(m_nTypeClass)>::get() );
      83           0 :     }
      84             : 
      85             : 
      86           0 :     void OXSDDataType::initializeClone( const OXSDDataType& _rCloneSource )
      87             :     {
      88           0 :         m_bIsBasic   = false;
      89           0 :         m_nTypeClass = _rCloneSource.m_nTypeClass;
      90           0 :         m_sPattern   = _rCloneSource.m_sPattern;
      91           0 :         m_nWST       = _rCloneSource.m_nWST;
      92           0 :     }
      93             : 
      94             : 
      95           0 :     OXSDDataType* OXSDDataType::clone( const OUString& _rNewName ) const
      96             :     {
      97           0 :         OXSDDataType* pClone = createClone( _rNewName );
      98           0 :         pClone->initializeClone( *this );
      99           0 :         return pClone;
     100             :     }
     101             : 
     102             : 
     103           0 :     IMPLEMENT_FORWARD_XINTERFACE2( OXSDDataType, OXSDDataType_Base, ::comphelper::OPropertyContainer )
     104             : 
     105             : 
     106           0 :     IMPLEMENT_FORWARD_XTYPEPROVIDER2( OXSDDataType, OXSDDataType_Base, ::comphelper::OPropertyContainer )
     107             : 
     108             : #define SET_PROPERTY( propertyid, value, member ) \
     109             :     setFastPropertyValue( PROPERTY_ID_##propertyid, makeAny( value ) ); \
     110             :     SAL_WARN_IF( member != value, "forms.misc", "OXSDDataType::setFoo: inconsistency!" );
     111             : 
     112             : 
     113           0 :     OUString SAL_CALL OXSDDataType::getName(  ) throw (RuntimeException, std::exception)
     114             :     {
     115           0 :         return m_sName;
     116             :     }
     117             : 
     118             : 
     119           0 :     void SAL_CALL OXSDDataType::setName( const OUString& aName ) throw (RuntimeException, VetoException, std::exception)
     120             :     {
     121             :         // TODO: check the name for conflicts in the repository
     122           0 :         SET_PROPERTY( NAME, aName, m_sName );
     123           0 :     }
     124             : 
     125             : 
     126           0 :     OUString SAL_CALL OXSDDataType::getPattern() throw (RuntimeException, std::exception)
     127             :     {
     128           0 :         return m_sPattern;
     129             :     }
     130             : 
     131             : 
     132           0 :     void SAL_CALL OXSDDataType::setPattern( const OUString& _pattern ) throw (RuntimeException, std::exception)
     133             :     {
     134           0 :         SET_PROPERTY( XSD_PATTERN, _pattern, m_sPattern );
     135           0 :     }
     136             : 
     137             : 
     138           0 :     sal_Int16 SAL_CALL OXSDDataType::getWhiteSpaceTreatment() throw (RuntimeException, std::exception)
     139             :     {
     140           0 :         return m_nWST;
     141             :     }
     142             : 
     143             : 
     144           0 :     void SAL_CALL OXSDDataType::setWhiteSpaceTreatment( sal_Int16 _whitespacetreatment ) throw (RuntimeException, IllegalArgumentException, std::exception)
     145             :     {
     146           0 :         SET_PROPERTY( XSD_WHITESPACE, _whitespacetreatment, m_nWST );
     147           0 :     }
     148             : 
     149             : 
     150           0 :     sal_Bool SAL_CALL OXSDDataType::getIsBasic() throw (RuntimeException, std::exception)
     151             :     {
     152           0 :         return m_bIsBasic;
     153             :     }
     154             : 
     155             : 
     156             : 
     157           0 :     sal_Int16 SAL_CALL OXSDDataType::getTypeClass() throw (RuntimeException, std::exception)
     158             :     {
     159           0 :         return m_nTypeClass;
     160             :     }
     161             : 
     162             : 
     163           0 :     sal_Bool OXSDDataType::validate( const OUString& sValue ) throw( RuntimeException, std::exception )
     164             :     {
     165           0 :         return ( _validate( sValue ) == 0 );
     166             :     }
     167             : 
     168             : 
     169           0 :   OUString OXSDDataType::explainInvalid( const OUString& sValue ) throw( RuntimeException, std::exception )
     170             :     {
     171             :         // get reason
     172           0 :         sal_uInt16 nReason = _validate( sValue );
     173             : 
     174             :         // get resource and return localized string
     175             :         return ( nReason == 0 )
     176             :             ? OUString()
     177             :             : getResource( nReason, sValue,
     178           0 :                                    _explainInvalid( nReason ) );
     179             :     }
     180             : 
     181             : 
     182           0 :     OUString OXSDDataType::_explainInvalid( sal_uInt16 nReason )
     183             :     {
     184           0 :         if ( RID_STR_XFORMS_PATTERN_DOESNT_MATCH == nReason )
     185             :         {
     186             :             OSL_ENSURE( !m_sPattern.isEmpty(), "OXSDDataType::_explainInvalid: how can this error occur without a regular expression?" );
     187           0 :             return m_sPattern;
     188             :         }
     189           0 :         return OUString();
     190             :     }
     191             : 
     192             : 
     193             :     namespace
     194             :     {
     195           0 :         static void lcl_initializePatternMatcher( ::std::unique_ptr< RegexMatcher >& _rpMatcher, const OUString& _rPattern )
     196             :         {
     197           0 :             UErrorCode nMatchStatus = U_ZERO_ERROR;
     198           0 :             UnicodeString aIcuPattern( reinterpret_cast<const UChar *>(_rPattern.getStr()), _rPattern.getLength() );    // UChar != sal_Unicode in MinGW
     199           0 :             _rpMatcher.reset( new RegexMatcher( aIcuPattern, 0, nMatchStatus ) );
     200           0 :             OSL_ENSURE( U_SUCCESS( nMatchStatus ), "lcl_initializePatternMatcher: invalid pattern property!" );
     201             :                 // if asserts, then something changed our pattern without going to convertFastPropertyValue/checkPropertySanity
     202           0 :         }
     203             : 
     204           0 :         static bool lcl_matchString( RegexMatcher& _rMatcher, const OUString& _rText )
     205             :         {
     206           0 :             UErrorCode nMatchStatus = U_ZERO_ERROR;
     207           0 :             UnicodeString aInput( reinterpret_cast<const UChar *>(_rText.getStr()), _rText.getLength() );   // UChar != sal_Unicode in MinGW
     208           0 :             _rMatcher.reset( aInput );
     209           0 :             if ( _rMatcher.matches( nMatchStatus ) )
     210             :             {
     211           0 :                 int32_t nStart = _rMatcher.start( nMatchStatus );
     212           0 :                 int32_t nEnd   = _rMatcher.end  ( nMatchStatus );
     213           0 :                 if ( ( nStart == 0 ) && ( nEnd == _rText.getLength() ) )
     214           0 :                     return true;
     215             :             }
     216             : 
     217           0 :             return false;
     218             :         }
     219             :     }
     220             : 
     221             : 
     222           0 :     sal_uInt16 OXSDDataType::_validate( const OUString& _rValue )
     223             :     {
     224             :         // care for the regular expression
     225           0 :         if ( !m_sPattern.isEmpty() )
     226             :         {
     227             :             // ensure our pattern matcher is up to date
     228           0 :             if ( m_bPatternMatcherDirty )
     229             :             {
     230           0 :                 lcl_initializePatternMatcher( m_pPatternMatcher, m_sPattern );
     231           0 :                 m_bPatternMatcherDirty = false;
     232             :             }
     233             : 
     234             :             // let it match the string
     235           0 :             if ( !lcl_matchString( *m_pPatternMatcher.get(), _rValue ) )
     236           0 :                 return RID_STR_XFORMS_PATTERN_DOESNT_MATCH;
     237             :         }
     238             : 
     239           0 :         return 0;
     240             :     }
     241             : 
     242             : 
     243           0 :     sal_Bool OXSDDataType::convertFastPropertyValue( Any& _rConvertedValue, Any& _rOldValue, sal_Int32 _nHandle, const Any& _rValue ) throw(IllegalArgumentException)
     244             :     {
     245             :         // let the base class do the conversion
     246           0 :         if ( !OXSDDataType_PBase::convertFastPropertyValue( _rConvertedValue, _rOldValue, _nHandle, _rValue ) )
     247           0 :             return sal_False;
     248             : 
     249             :         // sanity checks
     250           0 :         OUString sErrorMessage;
     251           0 :         if ( !checkPropertySanity( _nHandle, _rConvertedValue, sErrorMessage ) )
     252             :         {
     253           0 :             IllegalArgumentException aException;
     254           0 :             aException.Message = sErrorMessage;
     255           0 :             aException.Context = *this;
     256           0 :             throw IllegalArgumentException( aException );
     257             :         }
     258             : 
     259           0 :         return sal_True;
     260             :     }
     261             : 
     262             : 
     263           0 :     void SAL_CALL OXSDDataType::setFastPropertyValue_NoBroadcast( sal_Int32 _nHandle, const Any& _rValue ) throw (Exception, std::exception)
     264             :     {
     265           0 :         OXSDDataType_PBase::setFastPropertyValue_NoBroadcast( _nHandle, _rValue );
     266           0 :         if ( _nHandle == PROPERTY_ID_XSD_PATTERN )
     267           0 :             m_bPatternMatcherDirty = true;
     268           0 :     }
     269             : 
     270             : 
     271           0 :     bool OXSDDataType::checkPropertySanity( sal_Int32 _nHandle, const ::com::sun::star::uno::Any& _rNewValue, OUString& _rErrorMessage )
     272             :     {
     273           0 :         if ( _nHandle == PROPERTY_ID_XSD_PATTERN )
     274             :         {
     275           0 :             OUString sPattern;
     276           0 :             OSL_VERIFY( _rNewValue >>= sPattern );
     277             : 
     278           0 :             UnicodeString aIcuPattern( reinterpret_cast<const UChar *>(sPattern.getStr()), sPattern.getLength() );  // UChar != sal_Unicode in MinGW
     279           0 :             UErrorCode nMatchStatus = U_ZERO_ERROR;
     280           0 :             RegexMatcher aMatcher( aIcuPattern, 0, nMatchStatus );
     281           0 :             if ( U_FAILURE( nMatchStatus ) )
     282             :             {
     283           0 :                 _rErrorMessage = "This is no valid pattern.";
     284           0 :                 return false;
     285           0 :             }
     286             :         }
     287           0 :         return true;
     288             :     }
     289             : 
     290             : 
     291           0 :     void SAL_CALL OXSDDataType::setPropertyValue( const OUString& aPropertyName, const Any& aValue ) throw (UnknownPropertyException, PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException, std::exception)
     292             :     {
     293           0 :         OXSDDataType_PBase::setPropertyValue( aPropertyName, aValue );
     294           0 :     }
     295             : 
     296             : 
     297           0 :     Any SAL_CALL OXSDDataType::getPropertyValue( const OUString& PropertyName ) throw (UnknownPropertyException, WrappedTargetException, RuntimeException, std::exception)
     298             :     {
     299           0 :         return OXSDDataType_PBase::getPropertyValue( PropertyName );
     300             :     }
     301             : 
     302             : 
     303           0 :     void SAL_CALL OXSDDataType::addPropertyChangeListener( const OUString& aPropertyName, const Reference< XPropertyChangeListener >& xListener ) throw (UnknownPropertyException, WrappedTargetException, RuntimeException, std::exception)
     304             :     {
     305           0 :         OXSDDataType_PBase::addPropertyChangeListener( aPropertyName, xListener );
     306           0 :     }
     307             : 
     308             : 
     309           0 :     void SAL_CALL OXSDDataType::removePropertyChangeListener( const OUString& aPropertyName, const Reference< XPropertyChangeListener >& aListener ) throw (UnknownPropertyException, WrappedTargetException, RuntimeException, std::exception)
     310             :     {
     311           0 :         OXSDDataType_PBase::removePropertyChangeListener( aPropertyName, aListener );
     312           0 :     }
     313             : 
     314             : 
     315           0 :     void SAL_CALL OXSDDataType::addVetoableChangeListener( const OUString& PropertyName, const Reference< XVetoableChangeListener >& aListener ) throw (UnknownPropertyException, WrappedTargetException, RuntimeException, std::exception)
     316             :     {
     317           0 :         OXSDDataType_PBase::addVetoableChangeListener( PropertyName, aListener );
     318           0 :     }
     319             : 
     320             : 
     321           0 :     void SAL_CALL OXSDDataType::removeVetoableChangeListener( const OUString& PropertyName, const Reference< XVetoableChangeListener >& aListener ) throw (UnknownPropertyException, WrappedTargetException, RuntimeException, std::exception)
     322             :     {
     323           0 :         OXSDDataType_PBase::removeVetoableChangeListener( PropertyName, aListener );
     324           0 :     }
     325             : 
     326           0 :     OValueLimitedType_Base::OValueLimitedType_Base( const OUString& _rName, sal_Int16 _nTypeClass )
     327             :         :OXSDDataType( _rName, _nTypeClass )
     328             :         ,m_fCachedMaxInclusive( 0 )
     329             :         ,m_fCachedMaxExclusive( 0 )
     330             :         ,m_fCachedMinInclusive( 0 )
     331           0 :         ,m_fCachedMinExclusive( 0 )
     332             :     {
     333           0 :     }
     334             : 
     335             : 
     336           0 :     void OValueLimitedType_Base::initializeClone( const OXSDDataType& _rCloneSource )
     337             :     {
     338           0 :         OXSDDataType::initializeClone( _rCloneSource );
     339           0 :         initializeTypedClone( static_cast< const OValueLimitedType_Base& >( _rCloneSource ) );
     340           0 :     }
     341             : 
     342             : 
     343           0 :     void OValueLimitedType_Base::initializeTypedClone( const OValueLimitedType_Base& _rCloneSource )
     344             :     {
     345           0 :         m_aMaxInclusive   = _rCloneSource.m_aMaxInclusive;
     346           0 :         m_aMaxExclusive   = _rCloneSource.m_aMaxExclusive;
     347           0 :         m_aMinInclusive   = _rCloneSource.m_aMinInclusive;
     348           0 :         m_aMinExclusive   = _rCloneSource.m_aMinExclusive;
     349           0 :         m_fCachedMaxInclusive   = _rCloneSource.m_fCachedMaxInclusive;
     350           0 :         m_fCachedMaxExclusive   = _rCloneSource.m_fCachedMaxExclusive;
     351           0 :         m_fCachedMinInclusive   = _rCloneSource.m_fCachedMinInclusive;
     352           0 :         m_fCachedMinExclusive   = _rCloneSource.m_fCachedMinExclusive;
     353           0 :     }
     354             : 
     355             : 
     356           0 :     void SAL_CALL OValueLimitedType_Base::setFastPropertyValue_NoBroadcast(
     357             :         sal_Int32 _nHandle, const ::com::sun::star::uno::Any& _rValue ) throw (::com::sun::star::uno::Exception, std::exception)
     358             :     {
     359           0 :         OXSDDataType::setFastPropertyValue_NoBroadcast( _nHandle, _rValue );
     360             : 
     361             :         // if one of our limit properties has been set, translate it into a double
     362             :         // value, for later efficient validation
     363           0 :         switch ( _nHandle )
     364             :         {
     365             :         case PROPERTY_ID_XSD_MAX_INCLUSIVE_INT:
     366             :         case PROPERTY_ID_XSD_MAX_INCLUSIVE_DOUBLE:
     367             :         case PROPERTY_ID_XSD_MAX_INCLUSIVE_DATE:
     368             :         case PROPERTY_ID_XSD_MAX_INCLUSIVE_TIME:
     369             :         case PROPERTY_ID_XSD_MAX_INCLUSIVE_DATE_TIME:
     370           0 :             if ( m_aMaxInclusive.hasValue() )
     371           0 :                 normalizeValue( m_aMaxInclusive, m_fCachedMaxInclusive );
     372             :             else
     373           0 :                 m_fCachedMaxInclusive = 0;
     374           0 :             break;
     375             :         case PROPERTY_ID_XSD_MAX_EXCLUSIVE_INT:
     376             :         case PROPERTY_ID_XSD_MAX_EXCLUSIVE_DOUBLE:
     377             :         case PROPERTY_ID_XSD_MAX_EXCLUSIVE_DATE:
     378             :         case PROPERTY_ID_XSD_MAX_EXCLUSIVE_TIME:
     379             :         case PROPERTY_ID_XSD_MAX_EXCLUSIVE_DATE_TIME:
     380           0 :             if ( m_aMaxExclusive.hasValue() )
     381           0 :                 normalizeValue( m_aMaxExclusive, m_fCachedMaxExclusive );
     382             :             else
     383           0 :                 m_fCachedMaxExclusive = 0;
     384           0 :             break;
     385             :         case PROPERTY_ID_XSD_MIN_INCLUSIVE_INT:
     386             :         case PROPERTY_ID_XSD_MIN_INCLUSIVE_DOUBLE:
     387             :         case PROPERTY_ID_XSD_MIN_INCLUSIVE_DATE:
     388             :         case PROPERTY_ID_XSD_MIN_INCLUSIVE_TIME:
     389             :         case PROPERTY_ID_XSD_MIN_INCLUSIVE_DATE_TIME:
     390           0 :             if ( m_aMinInclusive.hasValue() )
     391           0 :                 normalizeValue( m_aMinInclusive, m_fCachedMinInclusive );
     392             :             else
     393           0 :                 m_fCachedMinInclusive = 0;
     394           0 :             break;
     395             :         case PROPERTY_ID_XSD_MIN_EXCLUSIVE_INT:
     396             :         case PROPERTY_ID_XSD_MIN_EXCLUSIVE_DOUBLE:
     397             :         case PROPERTY_ID_XSD_MIN_EXCLUSIVE_DATE:
     398             :         case PROPERTY_ID_XSD_MIN_EXCLUSIVE_TIME:
     399             :         case PROPERTY_ID_XSD_MIN_EXCLUSIVE_DATE_TIME:
     400           0 :             if ( m_aMinExclusive.hasValue() )
     401           0 :                 normalizeValue( m_aMinExclusive, m_fCachedMinExclusive );
     402             :             else
     403           0 :                 m_fCachedMinExclusive = 0;
     404           0 :             break;
     405             :         }
     406           0 :     }
     407             : 
     408             : 
     409           0 :     bool OValueLimitedType_Base::_getValue( const OUString& rValue, double& fValue )
     410             :     {
     411             :         // convert to double
     412             :         rtl_math_ConversionStatus eStatus;
     413             :         sal_Int32 nEnd;
     414             :         double f = ::rtl::math::stringToDouble(
     415           0 :             rValue, '.', sal_Unicode(0), &eStatus, &nEnd );
     416             : 
     417             :         // error checking...
     418           0 :         bool bReturn = false;
     419           0 :         if( eStatus == rtl_math_ConversionStatus_Ok
     420           0 :             && nEnd == rValue.getLength() )
     421             :         {
     422           0 :             bReturn = true;
     423           0 :             fValue = f;
     424             :         }
     425           0 :         return bReturn;
     426             :     }
     427             : 
     428             : 
     429           0 :     sal_uInt16 OValueLimitedType_Base::_validate( const OUString& rValue )
     430             :     {
     431           0 :         sal_uInt16 nReason = OXSDDataType::_validate( rValue );
     432           0 :         if( nReason == 0 )
     433             :         {
     434             : 
     435             :             // convert value and check format
     436             :             double f;
     437           0 :             if( ! _getValue( rValue, f ) )
     438           0 :                 nReason = RID_STR_XFORMS_VALUE_IS_NOT_A;
     439             : 
     440             :             // check range
     441           0 :             else if( ( m_aMaxInclusive.hasValue() ) && f > m_fCachedMaxInclusive )
     442           0 :                 nReason = RID_STR_XFORMS_VALUE_MAX_INCL;
     443           0 :             else if( ( m_aMaxExclusive.hasValue() ) && f >= m_fCachedMaxExclusive )
     444           0 :                 nReason = RID_STR_XFORMS_VALUE_MAX_EXCL;
     445           0 :             else if( ( m_aMinInclusive.hasValue() ) && f < m_fCachedMinInclusive )
     446           0 :                 nReason = RID_STR_XFORMS_VALUE_MIN_INCL;
     447           0 :             else if( ( m_aMinExclusive.hasValue() ) && f <= m_fCachedMinExclusive )
     448           0 :                 nReason = RID_STR_XFORMS_VALUE_MIN_EXCL;
     449             :         }
     450           0 :         return nReason;
     451             :     }
     452             : 
     453             : 
     454           0 :     OUString OValueLimitedType_Base::_explainInvalid( sal_uInt16 nReason )
     455             :     {
     456           0 :         OUStringBuffer sInfo;
     457           0 :         switch( nReason )
     458             :         {
     459             :         case 0:
     460             :             // nothing to do!
     461           0 :             break;
     462             : 
     463             :         case RID_STR_XFORMS_VALUE_IS_NOT_A:
     464           0 :             sInfo.append( getName() );
     465           0 :             break;
     466             : 
     467             :         case RID_STR_XFORMS_VALUE_MAX_INCL:
     468           0 :             sInfo.append( typedValueAsHumanReadableString( m_aMaxInclusive ) );
     469           0 :             break;
     470             : 
     471             :         case RID_STR_XFORMS_VALUE_MAX_EXCL:
     472           0 :             sInfo.append( typedValueAsHumanReadableString( m_aMaxExclusive ) );
     473           0 :             break;
     474             : 
     475             :         case RID_STR_XFORMS_VALUE_MIN_INCL:
     476           0 :             sInfo.append( typedValueAsHumanReadableString( m_aMinInclusive ) );
     477           0 :             break;
     478             : 
     479             :         case RID_STR_XFORMS_VALUE_MIN_EXCL:
     480           0 :             sInfo.append( typedValueAsHumanReadableString( m_aMinExclusive ) );
     481           0 :             break;
     482             : 
     483             :         default:
     484             :             OSL_FAIL( "OValueLimitedType::_explainInvalid: unknown reason!" );
     485           0 :             break;
     486             :         }
     487             : 
     488           0 :         return sInfo.makeStringAndClear();
     489             :     }
     490             : 
     491           0 :     OStringType::OStringType( const OUString& _rName, sal_Int16 _nTypeClass )
     492           0 :         :OStringType_Base( _rName, _nTypeClass )
     493             :     {
     494           0 :     }
     495             : 
     496             : 
     497           0 :     void OStringType::registerProperties()
     498             :     {
     499           0 :         OStringType_Base::registerProperties();
     500             : 
     501           0 :         REGISTER_VOID_PROP( XSD_LENGTH,     m_aLength,    sal_Int32 );
     502           0 :         REGISTER_VOID_PROP( XSD_MIN_LENGTH, m_aMinLength, sal_Int32 );
     503           0 :         REGISTER_VOID_PROP( XSD_MAX_LENGTH, m_aMaxLength, sal_Int32 );
     504           0 :     }
     505             : 
     506             : 
     507           0 :     IMPLEMENT_DEFAULT_TYPED_CLONING( OStringType, OStringType_Base )
     508             : 
     509             : 
     510           0 :     void OStringType::initializeTypedClone( const OStringType& _rCloneSource )
     511             :     {
     512           0 :         m_aLength       = _rCloneSource.m_aLength;
     513           0 :         m_aMinLength    = _rCloneSource.m_aMinLength;
     514           0 :         m_aMaxLength    = _rCloneSource.m_aMaxLength;
     515           0 :     }
     516             : 
     517             : 
     518           0 :     bool OStringType::checkPropertySanity( sal_Int32 _nHandle, const Any& _rNewValue, OUString& _rErrorMessage )
     519             :     {
     520             :         // let the base class do the conversion
     521           0 :         if ( !OStringType_Base::checkPropertySanity( _nHandle, _rNewValue, _rErrorMessage ) )
     522           0 :             return false;
     523             : 
     524           0 :         _rErrorMessage.clear();
     525           0 :         switch ( _nHandle )
     526             :         {
     527             :             case PROPERTY_ID_XSD_LENGTH:
     528             :             case PROPERTY_ID_XSD_MIN_LENGTH:
     529             :             case PROPERTY_ID_XSD_MAX_LENGTH:
     530             :             {
     531           0 :                 sal_Int32 nValue( 0 );
     532           0 :                 OSL_VERIFY( _rNewValue >>= nValue );
     533           0 :                 if ( nValue <= 0 )
     534           0 :                     _rErrorMessage = "Length limits must denote positive integer values.";
     535             :                         // TODO/eforms: localize the error message
     536             :             }
     537           0 :             break;
     538             :         }
     539             : 
     540           0 :         return _rErrorMessage.isEmpty();
     541             :     }
     542             : 
     543             : 
     544           0 :     sal_uInt16 OStringType::_validate( const OUString& rValue )
     545             :     {
     546             :         // check regexp, whitespace etc. in parent class
     547           0 :         sal_uInt16 nReason = OStringType_Base::_validate( rValue );
     548             : 
     549           0 :         if( nReason == 0 )
     550             :         {
     551             :             // check string constraints
     552           0 :             sal_Int32 nLength = rValue.getLength();
     553           0 :             sal_Int32 nLimit = 0;
     554           0 :             if ( m_aLength >>= nLimit )
     555             :             {
     556           0 :                 if ( nLimit != nLength )
     557           0 :                     nReason = RID_STR_XFORMS_VALUE_LENGTH;
     558             :             }
     559             :             else
     560             :             {
     561           0 :                 if ( ( m_aMaxLength >>= nLimit ) && ( nLength > nLimit ) )
     562           0 :                     nReason = RID_STR_XFORMS_VALUE_MAX_LENGTH;
     563           0 :                 else if ( ( m_aMinLength >>= nLimit ) && ( nLength < nLimit ) )
     564           0 :                     nReason = RID_STR_XFORMS_VALUE_MIN_LENGTH;
     565             :             }
     566             :         }
     567           0 :         return nReason;
     568             :     }
     569             : 
     570             : 
     571           0 :     OUString OStringType::_explainInvalid( sal_uInt16 nReason )
     572             :     {
     573           0 :         sal_Int32 nValue = 0;
     574           0 :         OUStringBuffer sInfo;
     575           0 :         switch( nReason )
     576             :         {
     577             :         case 0:
     578             :             // nothing to do!
     579           0 :             break;
     580             : 
     581             :         case RID_STR_XFORMS_VALUE_LENGTH:
     582           0 :             if( m_aLength >>= nValue )
     583           0 :                 sInfo.append( nValue );
     584           0 :             break;
     585             : 
     586             :         case RID_STR_XFORMS_VALUE_MAX_LENGTH:
     587           0 :             if( m_aMaxLength >>= nValue )
     588           0 :                 sInfo.append( nValue );
     589           0 :             break;
     590             : 
     591             :         case RID_STR_XFORMS_VALUE_MIN_LENGTH:
     592           0 :             if( m_aMinLength >>= nValue )
     593           0 :                 sInfo.append( nValue );
     594           0 :             break;
     595             : 
     596             :         default:
     597           0 :             sInfo.append( OStringType_Base::_explainInvalid( nReason ) );
     598           0 :             break;
     599             :         }
     600           0 :         return sInfo.makeStringAndClear();
     601             :     }
     602             : 
     603           0 :     OBooleanType::OBooleanType( const OUString& _rName )
     604           0 :         :OBooleanType_Base( _rName, DataTypeClass::BOOLEAN )
     605             :     {
     606           0 :     }
     607             : 
     608           0 :     OXSDDataType* OBooleanType::createClone( const OUString& _rName ) const
     609             :     {
     610           0 :         return new OBooleanType( _rName );
     611             :     }
     612             : 
     613           0 :     void OBooleanType::initializeClone( const OXSDDataType& _rCloneSource )
     614             :     {
     615           0 :         OBooleanType_Base::initializeClone( _rCloneSource );
     616           0 :     }
     617             : 
     618           0 :     sal_uInt16 OBooleanType::_validate( const OUString& sValue )
     619             :     {
     620           0 :         sal_uInt16 nInvalidityReason = OBooleanType_Base::_validate( sValue );
     621           0 :         if ( nInvalidityReason )
     622           0 :             return nInvalidityReason;
     623             : 
     624           0 :         bool bValid = sValue == "0" || sValue == "1" || sValue == "true" || sValue == "false";
     625           0 :         return bValid ? 0 : RID_STR_XFORMS_INVALID_VALUE;
     626             :     }
     627             : 
     628             : 
     629           0 :     OUString OBooleanType::_explainInvalid( sal_uInt16 nReason )
     630             :     {
     631           0 :         return ( nReason == 0 ) ? OUString() : getName();
     632             :     }
     633             : 
     634           0 :     ODecimalType::ODecimalType( const OUString& _rName, sal_Int16 _nTypeClass )
     635           0 :         :ODecimalType_Base( _rName, _nTypeClass )
     636             :     {
     637           0 :     }
     638             : 
     639             : 
     640           0 :     IMPLEMENT_DEFAULT_TYPED_CLONING( ODecimalType, ODecimalType_Base )
     641             : 
     642             : 
     643           0 :     void ODecimalType::initializeTypedClone( const ODecimalType& _rCloneSource )
     644             :     {
     645           0 :         m_aTotalDigits    = _rCloneSource.m_aTotalDigits;
     646           0 :         m_aFractionDigits = _rCloneSource.m_aFractionDigits;
     647           0 :     }
     648             : 
     649             : 
     650           0 :     void ODecimalType::registerProperties()
     651             :     {
     652           0 :         ODecimalType_Base::registerProperties();
     653             : 
     654           0 :         REGISTER_VOID_PROP( XSD_TOTAL_DIGITS,    m_aTotalDigits,    sal_Int32 );
     655           0 :         REGISTER_VOID_PROP( XSD_FRACTION_DIGITS, m_aFractionDigits, sal_Int32 );
     656           0 :     }
     657             : 
     658             : 
     659             : 
     660             :     // validate decimals and return code for which facets failed
     661             :     // to be used by: ODecimalType::validate and ODecimalType::explainInvalid
     662           0 :     sal_uInt16 ODecimalType::_validate( const OUString& rValue )
     663             :     {
     664           0 :         sal_Int16 nReason = ODecimalType_Base::_validate( rValue );
     665             : 
     666             :         // check digits (if no other cause is available so far)
     667           0 :         if( nReason == 0 )
     668             :         {
     669           0 :             sal_Int32 nLength = rValue.getLength();
     670           0 :             sal_Int32 n = 0;
     671           0 :             sal_Int32 nTotalDigits = 0;
     672           0 :             sal_Int32 nFractionDigits = 0;
     673           0 :             const sal_Unicode* pValue = rValue.getStr();
     674           0 :             for( ; n < nLength && pValue[n] != '.'; n++ )
     675           0 :                 if( pValue[n] >= '0'
     676           0 :                     && pValue[n] <= '9')
     677           0 :                     nTotalDigits++;
     678           0 :             for( ; n < nLength; n++ )
     679           0 :                 if( pValue[n] >= '0'
     680           0 :                     && pValue[n] <= '9')
     681           0 :                     nFractionDigits++;
     682           0 :             nTotalDigits += nFractionDigits;
     683             : 
     684           0 :             sal_Int32 nValue = 0;
     685           0 :             if( ( m_aTotalDigits >>= nValue ) &&  nTotalDigits > nValue )
     686           0 :                 nReason = RID_STR_XFORMS_VALUE_TOTAL_DIGITS;
     687           0 :             else if( ( m_aFractionDigits >>= nValue ) &&
     688           0 :                      ( nFractionDigits > nValue ) )
     689           0 :                 nReason = RID_STR_XFORMS_VALUE_FRACTION_DIGITS;
     690             :         }
     691             : 
     692           0 :         return nReason;
     693             :     }
     694             : 
     695             : 
     696           0 :     OUString ODecimalType::_explainInvalid( sal_uInt16 nReason )
     697             :     {
     698           0 :         sal_Int32 nValue = 0;
     699           0 :         OUStringBuffer sInfo;
     700           0 :         switch( nReason )
     701             :         {
     702             :         case RID_STR_XFORMS_VALUE_TOTAL_DIGITS:
     703           0 :             if( m_aTotalDigits >>= nValue )
     704           0 :                 sInfo.append( nValue );
     705           0 :             break;
     706             : 
     707             :         case RID_STR_XFORMS_VALUE_FRACTION_DIGITS:
     708           0 :             if( m_aFractionDigits >>= nValue )
     709           0 :                 sInfo.append( nValue );
     710           0 :             break;
     711             : 
     712             :         default:
     713           0 :             sInfo.append( ODecimalType_Base::_explainInvalid( nReason ) );
     714           0 :             break;
     715             :         }
     716           0 :         return sInfo.makeStringAndClear();
     717             :     }
     718             : 
     719             : 
     720           0 :     OUString ODecimalType::typedValueAsHumanReadableString( const Any& _rValue ) const
     721             :     {
     722           0 :         double fValue( 0 );
     723           0 :         normalizeValue( _rValue, fValue );
     724           0 :         return OUString::number( fValue );
     725             :     }
     726             : 
     727             : 
     728           0 :     void ODecimalType::normalizeValue( const Any& _rValue, double& _rDoubleValue ) const
     729             :     {
     730           0 :         OSL_VERIFY( _rValue >>= _rDoubleValue );
     731           0 :     }
     732             : 
     733             : 
     734             :     //=
     735             : 
     736             : #define DEFAULT_IMPLEMNENT_SUBTYPE( classname, typeclass )      \
     737             :     classname::classname( const OUString& _rName )       \
     738             :         :classname##_Base( _rName, DataTypeClass::typeclass )   \
     739             :     {                                                           \
     740             :     }                                                           \
     741             :     OXSDDataType* classname::createClone( const OUString& _rName ) const \
     742             :     {                                                       \
     743             :         return new classname( _rName );                     \
     744             :     }                                                       \
     745             :     void classname::initializeClone( const OXSDDataType& _rCloneSource ) \
     746             :     { \
     747             :          classname##_Base::initializeClone( _rCloneSource );        \
     748             :         initializeTypedClone( static_cast< const classname& >( _rCloneSource ) ); \
     749             :     } \
     750             : 
     751             : 
     752             : 
     753             :     //= ODateType
     754             : 
     755             : 
     756           0 :     DEFAULT_IMPLEMNENT_SUBTYPE( ODateType, DATE )
     757             : 
     758             : 
     759           0 :     sal_uInt16 ODateType::_validate( const OUString& _rValue )
     760             :     {
     761           0 :         return ODateType_Base::_validate( _rValue );
     762             :     }
     763             : 
     764             : 
     765           0 :     bool ODateType::_getValue( const OUString& value, double& fValue )
     766             :     {
     767           0 :         Any aTypeValue = Convert::get().toAny( value, getCppuType() );
     768             : 
     769           0 :         Date aValue;
     770           0 :         if ( !( aTypeValue >>= aValue ) )
     771           0 :             return false;
     772             : 
     773           0 :         ::Date aToolsDate( aValue.Day, aValue.Month, aValue.Year );
     774           0 :         fValue = aToolsDate.GetDate();
     775           0 :         return true;
     776             :     }
     777             : 
     778             : 
     779           0 :     OUString ODateType::typedValueAsHumanReadableString( const Any& _rValue ) const
     780             :     {
     781             :         OSL_PRECOND( _rValue.getValueType().equals( getCppuType() ), "ODateType::typedValueAsHumanReadableString: unexpected type" );
     782           0 :         return Convert::get().toXSD( _rValue );
     783             :     }
     784             : 
     785             : 
     786           0 :     void ODateType::normalizeValue( const Any& _rValue, double& _rDoubleValue ) const
     787             :     {
     788           0 :         Date aValue;
     789           0 :         OSL_VERIFY( _rValue >>= aValue );
     790           0 :         ::Date aToolsDate( aValue.Day, aValue.Month, aValue.Year );
     791           0 :         _rDoubleValue = aToolsDate.GetDate();
     792           0 :     }
     793             : 
     794             : 
     795             :     //= OTimeType
     796             : 
     797             : 
     798           0 :     DEFAULT_IMPLEMNENT_SUBTYPE( OTimeType, TIME )
     799             : 
     800             : 
     801           0 :     sal_uInt16 OTimeType::_validate( const OUString& _rValue )
     802             :     {
     803           0 :         return OTimeType_Base::_validate( _rValue );
     804             :     }
     805             : 
     806             : 
     807           0 :     bool OTimeType::_getValue( const OUString& value, double& fValue )
     808             :     {
     809           0 :         Any aTypedValue = Convert::get().toAny( value, getCppuType() );
     810             : 
     811           0 :         css::util::Time aValue;
     812           0 :         if ( !( aTypedValue >>= aValue ) )
     813           0 :             return false;
     814             : 
     815           0 :         ::tools::Time aToolsTime( aValue );
     816             :         // no loss/rounding; IEEE 754 double-precision floating-point
     817             :         // has a mantissa of 53 bits; we need at the very most 50 bits:
     818             :         // format of aToolsTime.GetTime() is (in decimal) hhmmssnnnnnnnnn
     819             :         // and 999999999999999 = 0x38D7EA4C67FFF
     820             :         // in reality I doubt we need (much) more than
     821             :         //     240000000000000 = 0x0DA475ABF0000
     822             :         // that is 48 bits
     823           0 :         fValue = aToolsTime.GetTime();
     824           0 :         return true;
     825             :     }
     826             : 
     827             : 
     828           0 :     OUString OTimeType::typedValueAsHumanReadableString( const Any& _rValue ) const
     829             :     {
     830             :         OSL_PRECOND( _rValue.getValueType().equals( getCppuType() ), "OTimeType::typedValueAsHumanReadableString: unexpected type" );
     831           0 :         return Convert::get().toXSD( _rValue );
     832             :     }
     833             : 
     834             : 
     835           0 :     void OTimeType::normalizeValue( const Any& _rValue, double& _rDoubleValue ) const
     836             :     {
     837           0 :         css::util::Time aValue;
     838           0 :         OSL_VERIFY( _rValue >>= aValue );
     839           0 :         ::tools::Time aToolsTime( aValue );
     840           0 :         _rDoubleValue = aToolsTime.GetTime();
     841           0 :     }
     842             : 
     843             : 
     844             :     //= ODateTimeType
     845             : 
     846             : 
     847           0 :     DEFAULT_IMPLEMNENT_SUBTYPE( ODateTimeType, DATETIME )
     848             : 
     849             : 
     850           0 :     sal_uInt16 ODateTimeType::_validate( const OUString& _rValue )
     851             :     {
     852           0 :         return ODateTimeType_Base::_validate( _rValue );
     853             :     }
     854             : 
     855             : 
     856             :     namespace
     857             :     {
     858           0 :         double lcl_normalizeDateTime( const DateTime& _rValue )
     859             :         {
     860           0 :             ::DateTime aToolsValue(_rValue);
     861             : 
     862           0 :             double fValue = 0;
     863             :             // days since 1.1.1900 (which is relatively arbitrary but fixed date)
     864           0 :             fValue += ::Date( aToolsValue ) - ::Date( 1, 1, 1900 );
     865             :             // time
     866           0 :             fValue += aToolsValue.GetTimeInDays();
     867           0 :             return fValue;
     868             :         }
     869             :     }
     870             : 
     871             : 
     872           0 :     bool ODateTimeType::_getValue( const OUString& value, double& fValue )
     873             :     {
     874           0 :         Any aTypedValue = Convert::get().toAny( value, getCppuType() );
     875             : 
     876           0 :         DateTime aValue;
     877           0 :         if ( !( aTypedValue >>= aValue ) )
     878           0 :             return false;
     879             : 
     880           0 :         fValue = lcl_normalizeDateTime( aValue );
     881           0 :         return true;
     882             :     }
     883             : 
     884             : 
     885           0 :     OUString ODateTimeType::typedValueAsHumanReadableString( const Any& _rValue ) const
     886             :     {
     887             :         OSL_PRECOND( _rValue.getValueType().equals( getCppuType() ), "OTimeType::typedValueAsHumanReadableString: unexpected type" );
     888           0 :         OUString sString = Convert::get().toXSD( _rValue );
     889             : 
     890             :         // ISO 8601 notation has a "T" to separate between date and time. Our only concession
     891             :         // to the "human readable" in the method name is to replace this T with a whitespace.
     892             :         OSL_ENSURE( sString.indexOf( 'T' ) != -1, "ODateTimeType::typedValueAsHumanReadableString: hmm - no ISO notation?" );
     893           0 :         return sString.replace( 'T', ' ' );
     894             :     }
     895             : 
     896             : 
     897           0 :     void ODateTimeType::normalizeValue( const Any& _rValue, double& _rDoubleValue ) const
     898             :     {
     899           0 :         DateTime aValue;
     900           0 :         OSL_VERIFY( _rValue >>= aValue );
     901           0 :         _rDoubleValue = lcl_normalizeDateTime( aValue );
     902           0 :     }
     903             : 
     904           0 :     OShortIntegerType::OShortIntegerType( const OUString& _rName, sal_Int16 _nTypeClass )
     905           0 :         :OShortIntegerType_Base( _rName, _nTypeClass )
     906             :     {
     907           0 :     }
     908             : 
     909             : 
     910           0 :     IMPLEMENT_DEFAULT_TYPED_CLONING( OShortIntegerType, OShortIntegerType_Base )
     911             : 
     912             : 
     913           0 :     bool OShortIntegerType::_getValue( const OUString& value, double& fValue )
     914             :     {
     915           0 :         fValue = (double)(sal_Int16)value.toInt32();
     916             :         // TODO/eforms
     917             :         // this does not care for values which do not fit into a sal_Int16, but simply
     918             :         // cuts them down. A better implementation here should probably return <FALSE/>
     919             :         // for those values.
     920             :         // Else, we may have a situation where the UI claims an input to be valid
     921             :         // (say "12345678"), while internally, and at submission time, this is cut to
     922             :         // some smaller value.
     923             : 
     924             :         // Additionally, this of course does not care for strings which are no numers ...
     925           0 :         return true;
     926             :     }
     927             : 
     928             : 
     929           0 :     OUString OShortIntegerType::typedValueAsHumanReadableString( const Any& _rValue ) const
     930             :     {
     931           0 :         sal_Int16 nValue( 0 );
     932           0 :         OSL_VERIFY( _rValue >>= nValue );
     933           0 :         return OUString::number( nValue );
     934             :     }
     935             : 
     936             : 
     937           0 :     void OShortIntegerType::normalizeValue( const Any& _rValue, double& _rDoubleValue ) const
     938             :     {
     939           0 :         sal_Int16 nValue( 0 );
     940           0 :         OSL_VERIFY( _rValue >>= nValue );
     941           0 :         _rDoubleValue = nValue;
     942           0 :     }
     943             : 
     944             : 
     945             : 
     946             : #define DATATYPES_INCLUDED_BY_MASTER_HEADER
     947             : #include "datatypes_impl.hxx"
     948             : #undef DATATYPES_INCLUDED_BY_MASTER_HEADER
     949             : 
     950             : 
     951             : } // namespace xforms
     952             : 
     953             : 
     954             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11