LCOV - code coverage report
Current view: top level - comphelper/source/property - propagg.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 378 421 89.8 %
Date: 2014-11-03 Functions: 41 46 89.1 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include <comphelper/propagg.hxx>
      21             : #include <comphelper/property.hxx>
      22             : #include <cppuhelper/queryinterface.hxx>
      23             : #include <osl/diagnose.h>
      24             : #include <com/sun/star/beans/PropertyAttribute.hpp>
      25             : 
      26             : #if OSL_DEBUG_LEVEL > 0
      27             : #include <typeinfo>
      28             : #include <rtl/strbuf.hxx>
      29             : #endif
      30             : 
      31             : #include <algorithm>
      32             : #include <set>
      33             : #include <boost/scoped_array.hpp>
      34             : 
      35             : 
      36             : namespace comphelper
      37             : {
      38             : 
      39             : 
      40             :     using namespace ::com::sun::star::uno;
      41             :     using namespace ::com::sun::star::lang;
      42             :     using namespace ::com::sun::star::beans;
      43             : 
      44             :     using namespace internal;
      45             : 
      46             : 
      47             :     namespace
      48             :     {
      49      196621 :         const Property* lcl_findPropertyByName( const Sequence< Property >& _rProps, const OUString& _rName )
      50             :         {
      51      196621 :             sal_Int32 nLen = _rProps.getLength();
      52      196621 :             const Property* pProperties = _rProps.getConstArray();
      53      196621 :             Property aNameProp(_rName, 0, Type(), 0);
      54      196621 :             const Property* pResult = ::std::lower_bound(pProperties, pProperties + nLen, aNameProp, PropertyCompareByName());
      55      196621 :             if ( pResult && ( pResult == pProperties + nLen || pResult->Name != _rName) )
      56         514 :                 pResult = NULL;
      57             : 
      58      196621 :             return pResult;
      59             :         }
      60             :     }
      61             : 
      62             : //= OPropertyArrayAggregationHelper
      63             : 
      64             : 
      65             : 
      66        1580 : OPropertyArrayAggregationHelper::OPropertyArrayAggregationHelper(
      67             :         const  Sequence< Property >& _rProperties, const  Sequence< Property >& _rAggProperties,
      68             :         IPropertyInfoService* _pInfoService, sal_Int32 _nFirstAggregateId )
      69        1580 :     :m_aProperties( _rProperties )
      70             : {
      71        1580 :     sal_Int32 nDelegatorProps = _rProperties.getLength();
      72        1580 :     sal_Int32 nAggregateProps = _rAggProperties.getLength();
      73             : 
      74             :     // make room for all properties
      75        1580 :     sal_Int32 nMergedProps = nDelegatorProps + nAggregateProps;
      76        1580 :     m_aProperties.realloc( nMergedProps );
      77             : 
      78        1580 :     const   Property* pAggregateProps   = _rAggProperties.getConstArray();
      79        1580 :     const   Property* pDelegateProps    = _rProperties.getConstArray();
      80        1580 :             Property* pMergedProps = m_aProperties.getArray();
      81             : 
      82             :     // if properties are present both at the delegatee and the aggregate, then the former are supposed to win.
      83             :     // So, we'll need an existence check.
      84        1580 :     ::std::set< OUString > aDelegatorProps;
      85             : 
      86             :     // create the map for the delegator properties
      87        1580 :     sal_Int32 nMPLoop = 0;
      88       36124 :     for ( ; nMPLoop < nDelegatorProps; ++nMPLoop, ++pDelegateProps )
      89             :     {
      90       34544 :         m_aPropertyAccessors[ pDelegateProps->Handle ] = OPropertyAccessor( -1, nMPLoop, false );
      91             :         OSL_ENSURE( aDelegatorProps.find( pDelegateProps->Name ) == aDelegatorProps.end(),
      92             :             "OPropertyArrayAggregationHelper::OPropertyArrayAggregationHelper: duplicate delegatee property!" );
      93       34544 :         aDelegatorProps.insert( pDelegateProps->Name );
      94             :     }
      95             : 
      96             :     // create the map for the aggregate properties
      97        1580 :     sal_Int32 nAggregateHandle = _nFirstAggregateId;
      98        1580 :     pMergedProps += nDelegatorProps;
      99       80932 :     for ( ; nMPLoop < nMergedProps; ++pAggregateProps )
     100             :     {
     101             :         // if the aggregate property is present at the delegatee already, ignore it
     102       79352 :         if ( aDelegatorProps.find( pAggregateProps->Name ) != aDelegatorProps.end() )
     103             :         {
     104         642 :             --nMergedProps;
     105         642 :             continue;
     106             :         }
     107             : 
     108             :         // next aggregate property - remember it
     109       78710 :         *pMergedProps = *pAggregateProps;
     110             : 
     111             :         // determine the handle for the property which we will expose to the outside world
     112       78710 :         sal_Int32 nHandle = -1;
     113             :         // ask the infor service first
     114       78710 :         if ( _pInfoService )
     115       76116 :             nHandle = _pInfoService->getPreferredPropertyId( pMergedProps->Name );
     116             : 
     117       78710 :         if ( -1 == nHandle )
     118             :             // no handle from the info service -> default
     119       46398 :             nHandle = nAggregateHandle++;
     120             :         else
     121             :         {   // check if we alread have a property with the given handle
     122       32312 :             const  Property* pPropsTilNow = m_aProperties.getConstArray();
     123     1526368 :             for ( sal_Int32 nCheck = 0; nCheck < nMPLoop; ++nCheck, ++pPropsTilNow )
     124     1494056 :                 if ( pPropsTilNow->Handle == nHandle )
     125             :                 {   // conflicts -> use another one (which we don't check anymore, assuming _nFirstAggregateId was large enough)
     126           0 :                     nHandle = nAggregateHandle++;
     127           0 :                     break;
     128             :                 }
     129             :         }
     130             : 
     131             :         // remember the accessor for this property
     132       78710 :         m_aPropertyAccessors[ nHandle ] = OPropertyAccessor( pMergedProps->Handle, nMPLoop, true );
     133       78710 :         pMergedProps->Handle = nHandle;
     134             : 
     135       78710 :         ++nMPLoop;
     136       78710 :         ++pMergedProps;
     137             :     }
     138        1580 :     m_aProperties.realloc( nMergedProps );
     139        1580 :     pMergedProps = m_aProperties.getArray();    // reset, needed again below
     140             : 
     141             :     // sort the properties by name
     142        1580 :     ::std::sort( pMergedProps, pMergedProps+nMergedProps, PropertyCompareByName());
     143             : 
     144        1580 :     pMergedProps = m_aProperties.getArray();
     145             : 
     146             :     // sync the map positions
     147      114834 :     for ( nMPLoop = 0; nMPLoop < nMergedProps; ++nMPLoop, ++pMergedProps )
     148      114834 :         m_aPropertyAccessors[ pMergedProps->Handle ].nPos = nMPLoop;
     149        1580 : }
     150             : 
     151             : 
     152      116300 : OPropertyArrayAggregationHelper::PropertyOrigin OPropertyArrayAggregationHelper::classifyProperty( const OUString& _rName )
     153             : {
     154      116300 :     PropertyOrigin eOrigin = UNKNOWN_PROPERTY;
     155             :     // look up the name
     156      116300 :     const Property* pPropertyDescriptor = lcl_findPropertyByName( m_aProperties, _rName );
     157      116300 :     if ( pPropertyDescriptor )
     158             :     {
     159             :         // look up the handle for this name
     160      116296 :         ConstPropertyAccessorMapIterator aPos = m_aPropertyAccessors.find( pPropertyDescriptor->Handle );
     161             :         OSL_ENSURE( m_aPropertyAccessors.end() != aPos, "OPropertyArrayAggregationHelper::classifyProperty: should have this handle in my map!" );
     162      116296 :         if ( m_aPropertyAccessors.end() != aPos )
     163             :         {
     164      116296 :             eOrigin = aPos->second.bAggregate ? AGGREGATE_PROPERTY : DELEGATOR_PROPERTY;
     165             :         }
     166             :     }
     167      116300 :     return eOrigin;
     168             : }
     169             : 
     170             : 
     171           0 : Property OPropertyArrayAggregationHelper::getPropertyByName( const OUString& _rPropertyName ) throw( UnknownPropertyException )
     172             : {
     173           0 :     const Property* pProperty = findPropertyByName( _rPropertyName );
     174             : 
     175           0 :     if ( !pProperty )
     176           0 :         throw  UnknownPropertyException();
     177             : 
     178           0 :     return *pProperty;
     179             : }
     180             : 
     181             : 
     182         266 : sal_Bool OPropertyArrayAggregationHelper::hasPropertyByName(const OUString& _rPropertyName)
     183             : {
     184         266 :     return NULL != findPropertyByName( _rPropertyName );
     185             : }
     186             : 
     187             : 
     188       80321 : const Property* OPropertyArrayAggregationHelper::findPropertyByName(const :: OUString& _rName ) const
     189             : {
     190       80321 :     return lcl_findPropertyByName( m_aProperties, _rName );
     191             : }
     192             : 
     193             : 
     194       80055 : sal_Int32 OPropertyArrayAggregationHelper::getHandleByName(const OUString& _rPropertyName)
     195             : {
     196       80055 :     const Property* pProperty = findPropertyByName( _rPropertyName );
     197       80055 :     return pProperty ? pProperty->Handle : -1;
     198             : }
     199             : 
     200             : 
     201       91149 : sal_Bool OPropertyArrayAggregationHelper::fillPropertyMembersByHandle(
     202             :             OUString* _pPropName, sal_Int16* _pAttributes, sal_Int32 _nHandle)
     203             : {
     204       91149 :     ConstPropertyAccessorMapIterator i = m_aPropertyAccessors.find(_nHandle);
     205       91149 :     bool bRet = i != m_aPropertyAccessors.end();
     206       91149 :     if (bRet)
     207             :     {
     208       90677 :         const  ::com::sun::star::beans::Property& rProperty = m_aProperties.getConstArray()[(*i).second.nPos];
     209       90677 :         if (_pPropName)
     210       19495 :             *_pPropName = rProperty.Name;
     211       90677 :         if (_pAttributes)
     212       51470 :             *_pAttributes = rProperty.Attributes;
     213             :     }
     214       91149 :     return bRet;
     215             : }
     216             : 
     217             : 
     218        1478 : bool OPropertyArrayAggregationHelper::getPropertyByHandle( sal_Int32 _nHandle, Property& _rProperty ) const
     219             : {
     220        1478 :     ConstPropertyAccessorMapIterator pos = m_aPropertyAccessors.find(_nHandle);
     221        1478 :     if ( pos != m_aPropertyAccessors.end() )
     222             :     {
     223        1478 :         _rProperty = m_aProperties[ pos->second.nPos ];
     224        1478 :         return true;
     225             :     }
     226           0 :     return false;
     227             : }
     228             : 
     229             : 
     230      191012 : bool OPropertyArrayAggregationHelper::fillAggregatePropertyInfoByHandle(
     231             :             OUString* _pPropName, sal_Int32* _pOriginalHandle, sal_Int32 _nHandle) const
     232             : {
     233      191012 :     ConstPropertyAccessorMapIterator i = m_aPropertyAccessors.find(_nHandle);
     234      191012 :     bool bRet = i != m_aPropertyAccessors.end() && (*i).second.bAggregate;
     235      191012 :     if (bRet)
     236             :     {
     237      141595 :         if (_pOriginalHandle)
     238      141595 :             *_pOriginalHandle = (*i).second.nOriginalHandle;
     239      141595 :         if (_pPropName)
     240             :         {
     241             :             OSL_ENSURE((*i).second.nPos < m_aProperties.getLength(),"Invalid index for sequence!");
     242      140939 :             const  ::com::sun::star::beans::Property& rProperty = m_aProperties.getConstArray()[(*i).second.nPos];
     243      140939 :             *_pPropName = rProperty.Name;
     244             :         }
     245             :     }
     246      191012 :     return bRet;
     247             : }
     248             : 
     249             : 
     250             : 
     251       45425 :  ::com::sun::star::uno::Sequence< ::com::sun::star::beans::Property> OPropertyArrayAggregationHelper::getProperties()
     252             : {
     253       45425 :     return m_aProperties;
     254             : }
     255             : 
     256             : 
     257             : 
     258        5878 : sal_Int32 OPropertyArrayAggregationHelper::fillHandles(
     259             :         sal_Int32* _pHandles, const  ::com::sun::star::uno::Sequence< OUString >& _rPropNames )
     260             : {
     261        5878 :     sal_Int32 nHitCount = 0;
     262        5878 :     const OUString* pReqProps = _rPropNames.getConstArray();
     263        5878 :     sal_Int32 nReqLen = _rPropNames.getLength();
     264             : 
     265             : #if OSL_DEBUG_LEVEL > 0
     266             :     // assure that the sequence is sorted
     267             :     {
     268             :         const OUString* pLookup = _rPropNames.getConstArray();
     269             :         const OUString* pEnd = _rPropNames.getConstArray() + _rPropNames.getLength() - 1;
     270             :         for (; pLookup < pEnd; ++pLookup)
     271             :         {
     272             :             const OUString* pCompare = pLookup + 1;
     273             :             const OUString* pCompareEnd = pEnd + 1;
     274             :             for (; pCompare < pCompareEnd; ++pCompare)
     275             :             {
     276             :                 OSL_ENSURE(pLookup->compareTo(*pCompare) < 0, "OPropertyArrayAggregationHelper::fillHandles : property names are not sorted!");
     277             :             }
     278             :         }
     279             :     }
     280             : #endif
     281             : 
     282        5878 :     const  ::com::sun::star::beans::Property* pCur = m_aProperties.getConstArray();
     283        5878 :     const  ::com::sun::star::beans::Property* pEnd = m_aProperties.getConstArray() + m_aProperties.getLength();
     284             : 
     285      142531 :     for( sal_Int32 i = 0; i < nReqLen; ++i )
     286             :     {
     287             :         // determine the logarithm
     288      136653 :         sal_uInt32 n = (sal_uInt32)(pEnd - pCur);
     289      136653 :         sal_Int32 nLog = 0;
     290      995800 :         while( n )
     291             :         {
     292      722494 :             nLog += 1;
     293      722494 :             n = n >> 1;
     294             :         }
     295             : 
     296             :         // (Number of properties yet to be found) * (Log2 of properties yet to be searched)
     297      136653 :         if( (nReqLen - i) * nLog >= pEnd - pCur )
     298             :         {
     299             :             // linear search is better
     300      429085 :             while( pCur < pEnd && pReqProps[i] > pCur->Name )
     301             :             {
     302      174255 :                 pCur++;
     303             :             }
     304      127415 :             if( pCur < pEnd && pReqProps[i] == pCur->Name )
     305             :             {
     306      127415 :                 _pHandles[i] = pCur->Handle;
     307      127415 :                 nHitCount++;
     308             :             }
     309             :             else
     310           0 :                 _pHandles[i] = -1;
     311             :         }
     312             :         else
     313             :         {
     314             :             // binary search is better
     315        9238 :             sal_Int32   nCompVal = 1;
     316        9238 :             const  ::com::sun::star::beans::Property*  pOldEnd = pEnd--;
     317        9238 :             const  ::com::sun::star::beans::Property*  pMid = pCur;
     318             : 
     319       54162 :             while( nCompVal != 0 && pCur <= pEnd )
     320             :             {
     321       35686 :                 pMid = (pEnd - pCur) / 2 + pCur;
     322             : 
     323       35686 :                 nCompVal = pReqProps[i].compareTo( pMid->Name );
     324             : 
     325       35686 :                 if( nCompVal > 0 )
     326       11062 :                     pCur = pMid + 1;
     327             :                 else
     328       24624 :                     pEnd = pMid - 1;
     329             :             }
     330             : 
     331        9238 :             if( nCompVal == 0 )
     332             :             {
     333        9238 :                 _pHandles[i] = pMid->Handle;
     334        9238 :                 nHitCount++;
     335        9238 :                 pCur = pMid +1;
     336             :             }
     337           0 :             else if( nCompVal > 0 )
     338             :             {
     339           0 :                 _pHandles[i] = -1;
     340           0 :                 pCur = pMid + 1;
     341             :             }
     342             :             else
     343             :             {
     344           0 :                 _pHandles[i] = -1;
     345           0 :                 pCur = pMid;
     346             :             }
     347        9238 :             pEnd = pOldEnd;
     348             :         }
     349             :     }
     350        5878 :     return nHitCount;
     351             : }
     352             : 
     353             : 
     354             : //= PropertyForwarder
     355             : 
     356             : namespace internal
     357             : {
     358             :     class PropertyForwarder
     359             :     {
     360             :     private:
     361             :         OPropertySetAggregationHelper&  m_rAggregationHelper;
     362             :         ::std::set< sal_Int32 >         m_aProperties;
     363             :         sal_Int32                       m_nCurrentlyForwarding;
     364             : 
     365             :     public:
     366             :         PropertyForwarder( OPropertySetAggregationHelper& _rAggregationHelper );
     367             :         ~PropertyForwarder();
     368             : 
     369             :         /** declares that the forwarder should be responsible for the given property
     370             : 
     371             :         @param _nHandle
     372             :             the public handle (<em>not</em> the original handle!) of the property
     373             :         */
     374             :         void    takeResponsibilityFor( sal_Int32 _nHandle );
     375             : 
     376             :         /** checks whether the forwarder is responsible for the given property
     377             :         */
     378             :         bool    isResponsibleFor( sal_Int32 _nHandle );
     379             : 
     380             :         /// actually forwards a property value to the aggregate
     381             :         void    doForward( sal_Int32 _nHandle, const Any& _rValue ) throw ( Exception );
     382             : 
     383       10254 :         sal_Int32 getCurrentlyForwardedProperty( ) const { return m_nCurrentlyForwarding; }
     384             :     };
     385             : 
     386             : 
     387        1904 :     PropertyForwarder::PropertyForwarder( OPropertySetAggregationHelper& _rAggregationHelper )
     388             :         :m_rAggregationHelper( _rAggregationHelper )
     389        1904 :         ,m_nCurrentlyForwarding( -1 )
     390             :     {
     391        1904 :     }
     392             : 
     393             : 
     394        1742 :     PropertyForwarder::~PropertyForwarder()
     395             :     {
     396        1742 :     }
     397             : 
     398             : 
     399         326 :     void PropertyForwarder::takeResponsibilityFor( sal_Int32 _nHandle )
     400             :     {
     401         326 :         m_aProperties.insert( _nHandle );
     402         326 :     }
     403             : 
     404             : 
     405        1478 :     bool PropertyForwarder::isResponsibleFor( sal_Int32 _nHandle )
     406             :     {
     407        1478 :         return m_aProperties.find( _nHandle ) != m_aProperties.end();
     408             :     }
     409             : 
     410             : 
     411         326 :     void PropertyForwarder::doForward( sal_Int32 _nHandle, const Any& _rValue ) throw ( Exception )
     412             :     {
     413             :         OSL_ENSURE( m_rAggregationHelper.m_xAggregateSet.is(), "PropertyForwarder::doForward: no property set!" );
     414         326 :         if ( m_rAggregationHelper.m_xAggregateSet.is() )
     415             :         {
     416         326 :             m_rAggregationHelper.forwardingPropertyValue( _nHandle );
     417             : 
     418             :             OSL_ENSURE( m_nCurrentlyForwarding == -1, "PropertyForwarder::doForward: reentrance?" );
     419         326 :             m_nCurrentlyForwarding = _nHandle;
     420             : 
     421             :             try
     422             :             {
     423         326 :                 m_rAggregationHelper.m_xAggregateSet->setPropertyValue( m_rAggregationHelper.getPropertyName( _nHandle ), _rValue );
     424             :                     // TODO: cache the property name? (it's a O(log n) search)
     425             :             }
     426           0 :             catch( const Exception& )
     427             :             {
     428           0 :                 m_rAggregationHelper.forwardedPropertyValue( _nHandle );
     429           0 :                 throw;
     430             :             }
     431             : 
     432         326 :             m_nCurrentlyForwarding = -1;
     433             : 
     434         326 :             m_rAggregationHelper.forwardedPropertyValue( _nHandle );
     435             :         }
     436         326 :     }
     437             : }
     438             : 
     439             : 
     440             : //= OPropertySetAggregationHelper
     441             : 
     442             : 
     443             : 
     444        1904 : OPropertySetAggregationHelper::OPropertySetAggregationHelper( ::cppu::OBroadcastHelper& rBHlp )
     445             :     :OPropertyStateHelper( rBHlp )
     446        1904 :     ,m_bListening( false )
     447             : {
     448        1904 :     m_pForwarder = new PropertyForwarder( *this );
     449        1904 : }
     450             : 
     451             : 
     452        3484 : OPropertySetAggregationHelper::~OPropertySetAggregationHelper()
     453             : {
     454        1742 :     delete m_pForwarder;
     455        1742 : }
     456             : 
     457             : 
     458      174941 :  ::com::sun::star::uno::Any SAL_CALL OPropertySetAggregationHelper::queryInterface(const  ::com::sun::star::uno::Type& _rType) throw( ::com::sun::star::uno::RuntimeException, std::exception)
     459             : {
     460      174941 :      ::com::sun::star::uno::Any aReturn = OPropertyStateHelper::queryInterface(_rType);
     461             : 
     462      174941 :     if ( !aReturn.hasValue() )
     463      212126 :         aReturn = cppu::queryInterface(_rType
     464             :         ,static_cast< ::com::sun::star::beans::XPropertiesChangeListener*>(this)
     465             :         ,static_cast< ::com::sun::star::beans::XVetoableChangeListener*>(this)
     466             :         ,static_cast< ::com::sun::star::lang::XEventListener*>(static_cast< ::com::sun::star::beans::XPropertiesChangeListener*>(this))
     467      106063 :         );
     468             : 
     469      174941 :     return aReturn;
     470             : }
     471             : 
     472             : 
     473        1610 : void OPropertySetAggregationHelper::disposing()
     474             : {
     475        1610 :     osl::MutexGuard aGuard(rBHelper.rMutex);
     476             : 
     477        1610 :     if ( m_xAggregateSet.is() && m_bListening )
     478             :     {
     479             :         // register as a single listener
     480        1258 :         m_xAggregateMultiSet->removePropertiesChangeListener(this);
     481        1258 :         m_xAggregateSet->removeVetoableChangeListener(OUString(), this);
     482        1258 :         m_bListening = false;
     483             :     }
     484             : 
     485        1610 :     OPropertyStateHelper::disposing();
     486        1610 : }
     487             : 
     488             : 
     489         290 : void SAL_CALL OPropertySetAggregationHelper::disposing(const  ::com::sun::star::lang::EventObject& _rSource) throw ( ::com::sun::star::uno::RuntimeException, std::exception)
     490             : {
     491             :     OSL_ENSURE(m_xAggregateSet.is(), "OPropertySetAggregationHelper::disposing : don't have an aggregate anymore !");
     492         290 :     if (_rSource.Source == m_xAggregateSet)
     493           0 :         m_bListening = false;
     494         290 : }
     495             : 
     496             : 
     497        8978 : void SAL_CALL OPropertySetAggregationHelper::propertiesChange(const  ::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyChangeEvent>& _rEvents) throw( ::com::sun::star::uno::RuntimeException, std::exception)
     498             : {
     499             :     OSL_ENSURE(m_xAggregateSet.is(), "OPropertySetAggregationHelper::propertiesChange : have no aggregate !");
     500             : 
     501        8978 :     sal_Int32 nLen = _rEvents.getLength();
     502        8978 :     cppu::IPropertyArrayHelper& rPH = getInfoHelper();
     503             : 
     504        8978 :     if (1 == nLen)
     505             :     {
     506        8552 :         const  ::com::sun::star::beans::PropertyChangeEvent& evt = _rEvents.getConstArray()[0];
     507             :         OSL_ENSURE(!evt.PropertyName.isEmpty(), "OPropertySetAggregationHelper::propertiesChange : invalid event !");
     508             :             // we had a bug where this assertion would have us saved a whole day :) (72514)
     509        8552 :         sal_Int32 nHandle = rPH.getHandleByName( evt.PropertyName );
     510             : 
     511             :         // If nHandle is -1 the event marks a (aggregate) property which we hide to callers
     512             :         // If isCurrentlyForwardingProperty( nHandle ) is <TRUE/>, then we ourself triggered
     513             :         // setting this property. In this case, it will be notified later (by the OPropertySetHelper
     514             :         // implementation)
     515             : 
     516        8552 :         if ( ( nHandle != -1 ) && !isCurrentlyForwardingProperty( nHandle ) )
     517        8248 :             fire(&nHandle, &evt.NewValue, &evt.OldValue, 1, sal_False);
     518             :     }
     519             :     else
     520             :     {
     521         426 :         boost::scoped_array<sal_Int32> pHandles(new sal_Int32[nLen]);
     522         852 :         boost::scoped_array< ::com::sun::star::uno::Any> pNewValues(new ::com::sun::star::uno::Any[nLen]);
     523         852 :         boost::scoped_array< ::com::sun::star::uno::Any> pOldValues(new ::com::sun::star::uno::Any[nLen]);
     524             : 
     525         426 :         const  ::com::sun::star::beans::PropertyChangeEvent* pEvents = _rEvents.getConstArray();
     526         426 :         sal_Int32 nDest = 0;
     527        2128 :         for (sal_Int32 nSource=0; nSource<nLen; ++nSource, ++pEvents)
     528             :         {
     529        1702 :             sal_Int32 nHandle = rPH.getHandleByName(pEvents->PropertyName);
     530        1702 :             if ( ( nHandle != -1 ) && !isCurrentlyForwardingProperty( nHandle ) )
     531             :             {   // same as above : -1 is valid (73247) ...
     532        1702 :                 pHandles[nDest] = nHandle;
     533        1702 :                 pNewValues[nDest] = pEvents->NewValue;
     534        1702 :                 pOldValues[nDest] = pEvents->OldValue;
     535        1702 :                 ++nDest;
     536             :             }
     537             :         }
     538             : 
     539         426 :         if (nDest)
     540         828 :             fire(pHandles.get(), pNewValues.get(), pOldValues.get(), nDest, sal_False);
     541             :     }
     542        8978 : }
     543             : 
     544             : 
     545           0 : void SAL_CALL OPropertySetAggregationHelper::vetoableChange(const  ::com::sun::star::beans::PropertyChangeEvent& _rEvent) throw( ::com::sun::star::beans::PropertyVetoException,  ::com::sun::star::uno::RuntimeException, std::exception)
     546             : {
     547             :     OSL_ENSURE(m_xAggregateSet.is(), "OPropertySetAggregationHelper::vetoableChange : have no aggregate !");
     548             : 
     549           0 :     cppu::IPropertyArrayHelper& rPH = getInfoHelper();
     550             : 
     551           0 :     sal_Int32 nHandle = rPH.getHandleByName(_rEvent.PropertyName);
     552           0 :     fire(&nHandle, &_rEvent.NewValue, &_rEvent.OldValue, 1, sal_True);
     553           0 : }
     554             : 
     555             : 
     556        1778 : void OPropertySetAggregationHelper::setAggregation(const  ::com::sun::star::uno::Reference<  ::com::sun::star::uno::XInterface >& _rxDelegate)
     557             :         throw(  ::com::sun::star::lang::IllegalArgumentException )
     558             : {
     559        1778 :     osl::MutexGuard aGuard(rBHelper.rMutex);
     560             : 
     561        1778 :     if (m_bListening && m_xAggregateSet.is())
     562             :     {
     563           0 :         m_xAggregateMultiSet->removePropertiesChangeListener(this);
     564           0 :         m_xAggregateSet->removeVetoableChangeListener(OUString(), this);
     565           0 :         m_bListening = false;
     566             :     }
     567             : 
     568        1778 :     m_xAggregateState.set(_rxDelegate, css::uno::UNO_QUERY);
     569        1778 :     m_xAggregateSet.set(_rxDelegate, css::uno::UNO_QUERY);
     570        1778 :     m_xAggregateMultiSet.set(_rxDelegate, css::uno::UNO_QUERY);
     571        1778 :     m_xAggregateFastSet.set(_rxDelegate, css::uno::UNO_QUERY);
     572             : 
     573             :     // must support XPropertySet and XMultiPropertySet
     574        1778 :     if ( m_xAggregateSet.is() && !m_xAggregateMultiSet.is() )
     575           0 :         throw  ::com::sun::star::lang::IllegalArgumentException();
     576        1778 : }
     577             : 
     578             : 
     579        1982 : void OPropertySetAggregationHelper::startListening()
     580             : {
     581        1982 :     osl::MutexGuard aGuard(rBHelper.rMutex);
     582             : 
     583        1982 :     if (!m_bListening && m_xAggregateSet.is())
     584             :     {
     585             :         // register as a single listener
     586        1384 :          ::com::sun::star::uno::Sequence< OUString > aPropertyNames;
     587        1384 :         m_xAggregateMultiSet->addPropertiesChangeListener(aPropertyNames, this);
     588        1384 :         m_xAggregateSet->addVetoableChangeListener(OUString(), this);
     589             : 
     590        1384 :         m_bListening = true;
     591        1982 :     }
     592        1982 : }
     593             : 
     594             : 
     595         264 : void SAL_CALL OPropertySetAggregationHelper::addVetoableChangeListener(const OUString& _rPropertyName,
     596             :                                                                        const  ::com::sun::star::uno::Reference< ::com::sun::star::beans::XVetoableChangeListener>& _rxListener)
     597             :                                                                        throw( ::com::sun::star::beans::UnknownPropertyException,  ::com::sun::star::lang::WrappedTargetException,  ::com::sun::star::uno::RuntimeException, std::exception)
     598             : {
     599         264 :     OPropertySetHelper::addVetoableChangeListener(_rPropertyName, _rxListener);
     600         264 :     if (!m_bListening)
     601           0 :         startListening();
     602         264 : }
     603             : 
     604             : 
     605        9243 : void SAL_CALL OPropertySetAggregationHelper::addPropertyChangeListener(const OUString& _rPropertyName,
     606             :                                                                        const  ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertyChangeListener>& _rxListener)
     607             :                                                                        throw( ::com::sun::star::beans::UnknownPropertyException,  ::com::sun::star::lang::WrappedTargetException,  ::com::sun::star::uno::RuntimeException, std::exception)
     608             : {
     609        9243 :     OPropertySetHelper::addPropertyChangeListener(_rPropertyName, _rxListener);
     610        9243 :     if (!m_bListening)
     611        1800 :         startListening();
     612        9243 : }
     613             : 
     614             : 
     615        1062 : void SAL_CALL OPropertySetAggregationHelper::addPropertiesChangeListener(const  ::com::sun::star::uno::Sequence< OUString >& _rPropertyNames,
     616             :                                                                          const  ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertiesChangeListener>& _rxListener)
     617             :                                                                          throw( ::com::sun::star::uno::RuntimeException, std::exception)
     618             : {
     619        1062 :     OPropertySetHelper::addPropertiesChangeListener(_rPropertyNames, _rxListener);
     620        1062 :     if (!m_bListening)
     621         182 :         startListening();
     622        1062 : }
     623             : 
     624             : 
     625         656 : sal_Int32 OPropertySetAggregationHelper::getOriginalHandle(sal_Int32 nHandle) const
     626             : {
     627         656 :     OPropertyArrayAggregationHelper& rPH = static_cast<OPropertyArrayAggregationHelper&>( const_cast<OPropertySetAggregationHelper*>(this)->getInfoHelper() );
     628         656 :     sal_Int32 nOriginalHandle = -1;
     629         656 :     (void)rPH.fillAggregatePropertyInfoByHandle(NULL, &nOriginalHandle, nHandle);
     630         656 :     return nOriginalHandle;
     631             : }
     632             : 
     633             : 
     634        1128 : OUString OPropertySetAggregationHelper::getPropertyName( sal_Int32 _nHandle ) const
     635             : {
     636        1128 :     OPropertyArrayAggregationHelper& rPH = static_cast< OPropertyArrayAggregationHelper& >( const_cast<OPropertySetAggregationHelper*>(this)->getInfoHelper() );
     637        1128 :     Property aProperty;
     638        1128 :     OSL_VERIFY( rPH.getPropertyByHandle( _nHandle, aProperty ) );
     639        1128 :     return aProperty.Name;
     640             : }
     641             : 
     642             : 
     643       18096 : void SAL_CALL OPropertySetAggregationHelper::setFastPropertyValue(sal_Int32 _nHandle, const  ::com::sun::star::uno::Any& _rValue)
     644             :         throw(   ::com::sun::star::beans::UnknownPropertyException,  ::com::sun::star::beans::PropertyVetoException,
     645             :                  ::com::sun::star::lang::IllegalArgumentException,  ::com::sun::star::lang::WrappedTargetException,
     646             :                  ::com::sun::star::uno::RuntimeException, std::exception)
     647             : {
     648       18096 :     OPropertyArrayAggregationHelper& rPH = static_cast< OPropertyArrayAggregationHelper& >( getInfoHelper() );
     649       18096 :     OUString aPropName;
     650       18096 :     sal_Int32   nOriginalHandle = -1;
     651             : 
     652             :     // does the handle belong to the aggregation ?
     653       18096 :     if (rPH.fillAggregatePropertyInfoByHandle(&aPropName, &nOriginalHandle, _nHandle))
     654       10760 :         if (m_xAggregateFastSet.is())
     655       10166 :             m_xAggregateFastSet->setFastPropertyValue(nOriginalHandle, _rValue);
     656             :         else
     657         594 :             m_xAggregateSet->setPropertyValue(aPropName, _rValue);
     658             :     else
     659        7416 :         OPropertySetHelper::setFastPropertyValue(_nHandle, _rValue);
     660       18016 : }
     661             : 
     662             : 
     663       90343 : void OPropertySetAggregationHelper::getFastPropertyValue( ::com::sun::star::uno::Any& rValue, sal_Int32 nHandle) const
     664             : {
     665       90343 :     OPropertyArrayAggregationHelper& rPH = static_cast<OPropertyArrayAggregationHelper&>( const_cast<OPropertySetAggregationHelper*>(this)->getInfoHelper() );
     666       90343 :     OUString aPropName;
     667       90343 :     sal_Int32   nOriginalHandle = -1;
     668             : 
     669       90343 :     if (rPH.fillAggregatePropertyInfoByHandle(&aPropName, &nOriginalHandle, nHandle))
     670             :     {
     671       89541 :         if (m_xAggregateFastSet.is())
     672       89541 :             rValue = m_xAggregateFastSet->getFastPropertyValue(nOriginalHandle);
     673             :         else
     674           0 :             rValue = m_xAggregateSet->getPropertyValue(aPropName);
     675             :     }
     676         802 :     else if ( m_pForwarder->isResponsibleFor( nHandle ) )
     677             :     {
     678             :         // this is a property which has been "overwritten" in our instance (thus
     679             :         // fillAggregatePropertyInfoByHandle didn't find it)
     680         802 :         rValue = m_xAggregateSet->getPropertyValue( getPropertyName( nHandle ) );
     681       90343 :     }
     682       90343 : }
     683             : 
     684             : 
     685       73861 :  ::com::sun::star::uno::Any SAL_CALL OPropertySetAggregationHelper::getFastPropertyValue(sal_Int32 nHandle)
     686             :         throw(   ::com::sun::star::beans::UnknownPropertyException,
     687             :                  ::com::sun::star::lang::WrappedTargetException,
     688             :                  ::com::sun::star::uno::RuntimeException, std::exception)
     689             : {
     690       73861 :     OPropertyArrayAggregationHelper& rPH = static_cast< OPropertyArrayAggregationHelper& >( getInfoHelper() );
     691       73861 :     OUString aPropName;
     692       73861 :     sal_Int32   nOriginalHandle = -1;
     693       73861 :      ::com::sun::star::uno::Any  aValue;
     694             : 
     695       73861 :     if (rPH.fillAggregatePropertyInfoByHandle(&aPropName, &nOriginalHandle, nHandle))
     696             :     {
     697       34820 :         if (m_xAggregateFastSet.is())
     698       22109 :             aValue = m_xAggregateFastSet->getFastPropertyValue(nOriginalHandle);
     699             :         else
     700       12711 :             aValue = m_xAggregateSet->getPropertyValue(aPropName);
     701             :     }
     702             :     else
     703       39041 :         aValue = OPropertySetHelper::getFastPropertyValue(nHandle);
     704             : 
     705       73507 :     return aValue;
     706             : }
     707             : 
     708             : 
     709        1772 : void SAL_CALL OPropertySetAggregationHelper::setPropertyValues(
     710             :         const Sequence< OUString >& _rPropertyNames, const Sequence< Any >& _rValues )
     711             :     throw ( PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException, std::exception )
     712             : {
     713             :     OSL_ENSURE( !rBHelper.bInDispose, "OPropertySetAggregationHelper::setPropertyValues : do not use within the dispose call !");
     714             :     OSL_ENSURE( !rBHelper.bDisposed, "OPropertySetAggregationHelper::setPropertyValues : object is disposed" );
     715             : 
     716             :     // check where the properties come from
     717        1772 :     if (!m_xAggregateSet.is())
     718         102 :         OPropertySetHelper::setPropertyValues(_rPropertyNames, _rValues);
     719        1670 :     else if (_rPropertyNames.getLength() == 1) // use the more efficient way
     720             :     {
     721             :         try
     722             :         {
     723         106 :             setPropertyValue( _rPropertyNames[0], _rValues[0] );
     724             :         }
     725           0 :         catch( const UnknownPropertyException& )
     726             :         {
     727             :             // by definition of XMultiPropertySet::setPropertyValues, unknown properties are to be ignored
     728             :         #if OSL_DEBUG_LEVEL > 0
     729             :             OStringBuffer aMessage;
     730             :             aMessage.append( "OPropertySetAggregationHelper::setPropertyValues: unknown property '" );
     731             :             aMessage.append( OUStringToOString( _rPropertyNames[0], RTL_TEXTENCODING_ASCII_US ) );
     732             :             aMessage.append( "'" );
     733             :             aMessage.append( "\n(implementation " );
     734             :             aMessage.append( typeid( *this ).name() );
     735             :             aMessage.append( ")" );
     736             :             OSL_FAIL( aMessage.getStr() );
     737             :         #endif
     738             :         }
     739             :     }
     740             :     else
     741             :     {
     742        1564 :         OPropertyArrayAggregationHelper& rPH = static_cast< OPropertyArrayAggregationHelper& >( getInfoHelper() );
     743             : 
     744             :         // determine which properties belong to the aggregate, and which ones to the delegator
     745        1564 :         const OUString* pNames = _rPropertyNames.getConstArray();
     746        1564 :         sal_Int32 nAggCount(0);
     747        1564 :         sal_Int32 nLen(_rPropertyNames.getLength());
     748             : 
     749       60734 :         for ( sal_Int32 i = 0; i < nLen; ++i, ++pNames )
     750             :         {
     751       59174 :             OPropertyArrayAggregationHelper::PropertyOrigin ePropOrg = rPH.classifyProperty( *pNames );
     752       59174 :             if ( OPropertyArrayAggregationHelper::UNKNOWN_PROPERTY == ePropOrg )
     753           4 :                 throw WrappedTargetException( OUString(), static_cast< XMultiPropertySet* >( this ), makeAny( UnknownPropertyException( ) ) );
     754             :                 // due to a flaw in the API design, this method is not allowed to throw an UnknownPropertyException
     755             :                 // so we wrap it into a WrappedTargetException
     756             : 
     757       59170 :             if ( OPropertyArrayAggregationHelper::AGGREGATE_PROPERTY == ePropOrg )
     758       44504 :                 ++nAggCount;
     759             :         }
     760             : 
     761        1560 :         pNames = _rPropertyNames.getConstArray();   // reset, we'll need it again below ...
     762             : 
     763             :         // all properties belong to the aggregate
     764        1560 :         if (nAggCount == nLen)
     765          42 :             m_xAggregateMultiSet->setPropertyValues(_rPropertyNames, _rValues);
     766             : 
     767             :         // all properties belong to the aggregating object
     768        1518 :         else if (nAggCount == 0)
     769          80 :             OPropertySetHelper::setPropertyValues(_rPropertyNames, _rValues);
     770             : 
     771             :         // mixed
     772             :         else
     773             :         {
     774        1438 :             const  ::com::sun::star::uno::Any* pValues = _rValues.getConstArray();
     775             : 
     776             :             try
     777             :             {
     778             :                 // dividing the Names and _rValues
     779             : 
     780             :                 // aggregate's names
     781        1438 :                 Sequence< OUString > AggPropertyNames( nAggCount );
     782        1438 :                 OUString* pAggNames = AggPropertyNames.getArray();
     783             :                 // aggregate's values
     784        2876 :                 Sequence< Any >  AggValues( nAggCount );
     785        1438 :                 Any* pAggValues = AggValues.getArray();
     786             : 
     787             :                 // delegator names
     788        2876 :                 Sequence< OUString > DelPropertyNames( nLen - nAggCount );
     789        1438 :                 OUString* pDelNames = DelPropertyNames.getArray();
     790             : 
     791             :                 // delegator values
     792        2876 :                 Sequence< Any > DelValues( nLen - nAggCount );
     793        1438 :                 Any* pDelValues = DelValues.getArray();
     794             : 
     795       58564 :                 for ( sal_Int32 i = 0; i < nLen; ++i, ++pNames, ++pValues )
     796             :                 {
     797       57126 :                     if ( OPropertyArrayAggregationHelper::AGGREGATE_PROPERTY == rPH.classifyProperty( *pNames ) )
     798             :                     {
     799       44188 :                         *pAggNames++ = *pNames;
     800       44188 :                         *pAggValues++ = *pValues;
     801             :                     }
     802             :                     else
     803             :                     {
     804       12938 :                         *pDelNames++ = *pNames;
     805       12938 :                         *pDelValues++ = *pValues;
     806             :                     }
     807             :                 }
     808             : 
     809             :                 // reset, needed below
     810        1438 :                 pDelValues = DelValues.getArray();
     811             : 
     812        2876 :                 boost::scoped_array<sal_Int32> pHandles(new sal_Int32[ nLen - nAggCount ]);
     813             : 
     814             :                 // get the map table
     815        1438 :                 cppu::IPropertyArrayHelper& rPH2 = getInfoHelper();
     816             : 
     817             :                 // fill the handle array
     818        1438 :                 sal_Int32 nHitCount = rPH2.fillHandles( pHandles.get(), DelPropertyNames );
     819        1438 :                 if (nHitCount != 0)
     820             :                 {
     821        1438 :                     boost::scoped_array< ::com::sun::star::uno::Any> pConvertedValues(new  ::com::sun::star::uno::Any[ nHitCount ]);
     822        2876 :                     boost::scoped_array< ::com::sun::star::uno::Any> pOldValues(new  ::com::sun::star::uno::Any[ nHitCount ]);
     823        1438 :                     nHitCount = 0;
     824             :                     sal_Int32 i;
     825             : 
     826             :                     {
     827             :                     // must lock the mutex outside the loop. So all values are consistent.
     828        1438 :                         osl::MutexGuard aGuard( rBHelper.rMutex );
     829       14376 :                         for( i = 0; i < (nLen - nAggCount); ++i )
     830             :                         {
     831       12938 :                             if( pHandles[i] != -1 )
     832             :                             {
     833             :                                 sal_Int16 nAttributes;
     834       12938 :                                 rPH2.fillPropertyMembersByHandle( NULL, &nAttributes, pHandles[i] );
     835       12938 :                                 if( nAttributes &  ::com::sun::star::beans::PropertyAttribute::READONLY )
     836           0 :                                     throw  ::com::sun::star::beans::PropertyVetoException();
     837             :                                 // Will the property change?
     838       25876 :                                 if( convertFastPropertyValue( pConvertedValues[ nHitCount ], pOldValues[nHitCount],
     839       25876 :                                                             pHandles[i], pDelValues[i] ) )
     840             :                                 {
     841             :                                     // only increment if the property really change
     842        1056 :                                     pHandles[nHitCount]         = pHandles[i];
     843        1056 :                                     nHitCount++;
     844             :                                 }
     845             :                             }
     846        1438 :                         }
     847             :                     // release guard to fire events
     848             :                     }
     849             : 
     850             :                     // fire vetoable events
     851        1438 :                     fire( pHandles.get(), pConvertedValues.get(), pOldValues.get(), nHitCount, sal_True );
     852             : 
     853             :                     // setting the agg Properties
     854        1438 :                     m_xAggregateMultiSet->setPropertyValues(AggPropertyNames, AggValues);
     855             : 
     856             :                     {
     857             :                     // must lock the mutex outside the loop.
     858        1436 :                         osl::MutexGuard aGuard( rBHelper.rMutex );
     859             :                         // Loop over all changed properties
     860        2480 :                         for( i = 0; i < nHitCount; i++ )
     861             :                         {
     862             :                             // Will the property change?
     863        1044 :                             setFastPropertyValue_NoBroadcast( pHandles[i], pConvertedValues[i] );
     864        1436 :                         }
     865             :                     // release guard to fire events
     866             :                     }
     867             : 
     868             :                     // fire change events
     869        2874 :                     fire( pHandles.get(), pConvertedValues.get(), pOldValues.get(), nHitCount, sal_False );
     870             :                 }
     871             :                 else
     872        1438 :                     m_xAggregateMultiSet->setPropertyValues(AggPropertyNames, AggValues);
     873             : 
     874             :             }
     875           2 :             catch(::com::sun::star::uno::Exception&)
     876             :             {
     877           2 :                 throw;
     878             :             }
     879             :         }
     880             :     }
     881        1724 : }
     882             : 
     883             : // XPropertyState
     884             : 
     885         824 :  ::com::sun::star::beans::PropertyState SAL_CALL OPropertySetAggregationHelper::getPropertyState(const OUString& _rPropertyName)
     886             :             throw( ::com::sun::star::beans::UnknownPropertyException,  ::com::sun::star::uno::RuntimeException, std::exception)
     887             : {
     888         824 :     OPropertyArrayAggregationHelper& rPH = static_cast< OPropertyArrayAggregationHelper& >( getInfoHelper() );
     889         824 :     sal_Int32 nHandle = rPH.getHandleByName( _rPropertyName );
     890             : 
     891         824 :     if (nHandle == -1)
     892             :     {
     893           0 :         throw  ::com::sun::star::beans::UnknownPropertyException();
     894             :     }
     895             : 
     896         824 :     OUString aPropName;
     897         824 :     sal_Int32   nOriginalHandle = -1;
     898         824 :     if (rPH.fillAggregatePropertyInfoByHandle(&aPropName, &nOriginalHandle, nHandle))
     899             :     {
     900         724 :         if (m_xAggregateState.is())
     901         724 :             return m_xAggregateState->getPropertyState(_rPropertyName);
     902             :         else
     903           0 :             return  ::com::sun::star::beans::PropertyState_DIRECT_VALUE;
     904             :     }
     905             :     else
     906         100 :         return getPropertyStateByHandle(nHandle);
     907             : }
     908             : 
     909             : 
     910          38 : void SAL_CALL OPropertySetAggregationHelper::setPropertyToDefault(const OUString& _rPropertyName)
     911             :         throw( ::com::sun::star::beans::UnknownPropertyException,  ::com::sun::star::uno::RuntimeException, std::exception)
     912             : {
     913          38 :     OPropertyArrayAggregationHelper& rPH = static_cast< OPropertyArrayAggregationHelper& >( getInfoHelper() );
     914          38 :     sal_Int32 nHandle = rPH.getHandleByName(_rPropertyName);
     915          38 :     if (nHandle == -1)
     916             :     {
     917           0 :         throw  ::com::sun::star::beans::UnknownPropertyException();
     918             :     }
     919             : 
     920          38 :     OUString aPropName;
     921          38 :     sal_Int32   nOriginalHandle = -1;
     922          38 :     if (rPH.fillAggregatePropertyInfoByHandle(&aPropName, &nOriginalHandle, nHandle))
     923             :     {
     924          32 :         if (m_xAggregateState.is())
     925          32 :             m_xAggregateState->setPropertyToDefault(_rPropertyName);
     926             :     }
     927             :     else
     928             :     {
     929             :         try
     930             :         {
     931           6 :             setPropertyToDefaultByHandle( nHandle );
     932             :         }
     933           0 :         catch( const UnknownPropertyException& ) { throw; }
     934           0 :         catch( const RuntimeException& ) { throw; }
     935           0 :         catch( const Exception& )
     936             :         {
     937             :             OSL_FAIL( "OPropertySetAggregationHelper::setPropertyToDefault: caught an exception which is not allowed to leave here!" );
     938             :         }
     939          38 :     }
     940          38 : }
     941             : 
     942             : 
     943          38 :  ::com::sun::star::uno::Any SAL_CALL OPropertySetAggregationHelper::getPropertyDefault(const OUString& aPropertyName)
     944             :         throw( ::com::sun::star::beans::UnknownPropertyException,  ::com::sun::star::lang::WrappedTargetException,  ::com::sun::star::uno::RuntimeException, std::exception)
     945             : {
     946          38 :     OPropertyArrayAggregationHelper& rPH = static_cast< OPropertyArrayAggregationHelper& >( getInfoHelper() );
     947          38 :     sal_Int32 nHandle = rPH.getHandleByName( aPropertyName );
     948             : 
     949          38 :     if ( nHandle == -1 )
     950           0 :         throw  ::com::sun::star::beans::UnknownPropertyException();
     951             : 
     952          38 :     OUString aPropName;
     953          38 :     sal_Int32   nOriginalHandle = -1;
     954          38 :     if (rPH.fillAggregatePropertyInfoByHandle(&aPropName, &nOriginalHandle, nHandle))
     955             :     {
     956          32 :         if (m_xAggregateState.is())
     957          32 :             return m_xAggregateState->getPropertyDefault(aPropertyName);
     958             :         else
     959           0 :             return  ::com::sun::star::uno::Any();
     960             :     }
     961             :     else
     962           6 :         return getPropertyDefaultByHandle(nHandle);
     963             : }
     964             : 
     965             : 
     966         350 : sal_Bool SAL_CALL OPropertySetAggregationHelper::convertFastPropertyValue( Any& _rConvertedValue, Any& _rOldValue, sal_Int32 _nHandle, const Any& _rValue ) throw(IllegalArgumentException)
     967             : {
     968         350 :     bool bModified = false;
     969             : 
     970             :     OSL_ENSURE( m_pForwarder->isResponsibleFor( _nHandle ), "OPropertySetAggregationHelper::convertFastPropertyValue: this is no forwarded property - did you use declareForwardedProperty for it?" );
     971         350 :     if ( m_pForwarder->isResponsibleFor( _nHandle ) )
     972             :     {
     973             :         // need to determine the type of the property for conversion
     974         350 :         OPropertyArrayAggregationHelper& rPH = static_cast< OPropertyArrayAggregationHelper& >( getInfoHelper() );
     975         350 :         Property aProperty;
     976         350 :         OSL_VERIFY( rPH.getPropertyByHandle( _nHandle, aProperty ) );
     977             : 
     978         700 :         Any aCurrentValue;
     979         350 :         getFastPropertyValue( aCurrentValue, _nHandle );
     980         700 :         bModified = tryPropertyValue( _rConvertedValue, _rOldValue, _rValue, aCurrentValue, aProperty.Type );
     981             :     }
     982             : 
     983         350 :     return bModified;
     984             : }
     985             : 
     986             : 
     987         326 : void SAL_CALL OPropertySetAggregationHelper::setFastPropertyValue_NoBroadcast( sal_Int32 _nHandle, const Any& _rValue ) throw ( Exception, std::exception )
     988             : {
     989             :     OSL_ENSURE( m_pForwarder->isResponsibleFor( _nHandle ), "OPropertySetAggregationHelper::setFastPropertyValue_NoBroadcast: this is no forwarded property - did you use declareForwardedProperty for it?" );
     990         326 :     if ( m_pForwarder->isResponsibleFor( _nHandle ) )
     991         326 :         m_pForwarder->doForward( _nHandle, _rValue );
     992         326 : }
     993             : 
     994             : 
     995         326 : void OPropertySetAggregationHelper::declareForwardedProperty( sal_Int32 _nHandle )
     996             : {
     997             :     OSL_ENSURE( !m_pForwarder->isResponsibleFor( _nHandle ), "OPropertySetAggregationHelper::declareForwardedProperty: already declared!" );
     998         326 :     m_pForwarder->takeResponsibilityFor( _nHandle );
     999         326 : }
    1000             : 
    1001             : 
    1002           0 : void OPropertySetAggregationHelper::forwardingPropertyValue( sal_Int32 )
    1003             : {
    1004             :     // not interested in
    1005           0 : }
    1006             : 
    1007             : 
    1008           0 : void OPropertySetAggregationHelper::forwardedPropertyValue( sal_Int32 )
    1009             : {
    1010             :     // not interested in
    1011           0 : }
    1012             : 
    1013             : 
    1014       10254 : bool OPropertySetAggregationHelper::isCurrentlyForwardingProperty( sal_Int32 _nHandle ) const
    1015             : {
    1016       10254 :     return m_pForwarder->getCurrentlyForwardedProperty() == _nHandle;
    1017             : }
    1018             : 
    1019             : 
    1020             : }   // namespace comphelper
    1021             : 
    1022             : 
    1023             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10