LCOV - code coverage report
Current view: top level - comphelper/source/property - propertycontainerhelper.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 172 175 98.3 %
Date: 2014-11-03 Functions: 22 22 100.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 <comphelper/propertycontainerhelper.hxx>
      21             : #include <comphelper/property.hxx>
      22             : #include <osl/diagnose.h>
      23             : #include <uno/data.h>
      24             : #include <com/sun/star/uno/genfunc.h>
      25             : #include <com/sun/star/beans/PropertyAttribute.hpp>
      26             : #include <com/sun/star/beans/UnknownPropertyException.hpp>
      27             : #include <rtl/ustrbuf.hxx>
      28             : 
      29             : #include <algorithm>
      30             : 
      31             : 
      32             : namespace comphelper
      33             : {
      34             : 
      35             : 
      36             : using namespace ::com::sun::star::uno;
      37             : using namespace ::com::sun::star::lang;
      38             : using namespace ::com::sun::star::beans;
      39             : 
      40             : 
      41             : namespace
      42             : {
      43             :     // comparing two property descriptions
      44             :     struct PropertyDescriptionHandleCompare : public ::std::binary_function< PropertyDescription, PropertyDescription, bool >
      45             :     {
      46     4980078 :         bool operator() (const PropertyDescription& x, const PropertyDescription& y) const
      47             :         {
      48     4980078 :             return x.aProperty.Handle < y.aProperty.Handle;
      49             :         }
      50             :     };
      51             :     // comparing two property descriptions (by name)
      52      316638 :     struct PropertyDescriptionNameMatch : public ::std::unary_function< PropertyDescription, bool >
      53             :     {
      54             :         OUString m_rCompare;
      55       35182 :         PropertyDescriptionNameMatch( const OUString& _rCompare ) : m_rCompare( _rCompare ) { }
      56             : 
      57      361348 :         bool operator() (const PropertyDescription& x ) const
      58             :         {
      59      361348 :             return x.aProperty.Name.equals(m_rCompare);
      60             :         }
      61             :     };
      62             : }
      63             : 
      64             : 
      65             : //= OPropertyContainerHelper
      66             : 
      67             : 
      68      193635 : OPropertyContainerHelper::OPropertyContainerHelper()
      69      193635 :     :m_bUnused(false)
      70             : {
      71      193635 : }
      72             : 
      73             : 
      74      193191 : OPropertyContainerHelper::~OPropertyContainerHelper()
      75             : {
      76      193191 : }
      77             : 
      78             : 
      79      357115 : void OPropertyContainerHelper::registerProperty(const OUString& _rName, sal_Int32 _nHandle,
      80             :         sal_Int32 _nAttributes, void* _pPointerToMember, const Type& _rMemberType)
      81             : {
      82             :     OSL_ENSURE((_nAttributes & PropertyAttribute::MAYBEVOID) == 0,
      83             :         "OPropertyContainerHelper::registerProperty: don't use this for properties which may be void ! There is a method called \"registerMayBeVoidProperty\" for this !");
      84             :     OSL_ENSURE(!_rMemberType.equals(cppu::UnoType<Any>::get()),
      85             :         "OPropertyContainerHelper::registerProperty: don't give my the type of an uno::Any ! Really can't handle this !");
      86             :     OSL_ENSURE(_pPointerToMember,
      87             :         "OPropertyContainerHelper::registerProperty: you gave me nonsense : the pointer must be non-NULL");
      88             : 
      89      357115 :     PropertyDescription aNewProp;
      90      357115 :     aNewProp.aProperty = Property( _rName, _nHandle, _rMemberType, (sal_Int16)_nAttributes );
      91      357115 :     aNewProp.eLocated = PropertyDescription::ltDerivedClassRealType;
      92      357115 :     aNewProp.aLocation.pDerivedClassMember = _pPointerToMember;
      93             : 
      94      357115 :     implPushBackProperty(aNewProp);
      95      357115 : }
      96             : 
      97             : 
      98          44 : void OPropertyContainerHelper::revokeProperty( sal_Int32 _nHandle )
      99             : {
     100          44 :     PropertiesIterator aPos = searchHandle( _nHandle );
     101          44 :     if ( aPos == m_aProperties.end() )
     102           0 :         throw UnknownPropertyException();
     103          44 :     m_aProperties.erase( aPos );
     104          44 : }
     105             : 
     106             : 
     107       23914 : void OPropertyContainerHelper::registerMayBeVoidProperty(const OUString& _rName, sal_Int32 _nHandle, sal_Int32 _nAttributes,
     108             :         Any* _pPointerToMember, const Type& _rExpectedType)
     109             : {
     110             :     OSL_ENSURE((_nAttributes & PropertyAttribute::MAYBEVOID) != 0,
     111             :         "OPropertyContainerHelper::registerMayBeVoidProperty: why calling this when the attributes say nothing about may-be-void ?");
     112             :     OSL_ENSURE(!_rExpectedType.equals(cppu::UnoType<Any>::get()),
     113             :         "OPropertyContainerHelper::registerMayBeVoidProperty: don't give my the type of an uno::Any ! Really can't handle this !");
     114             :     OSL_ENSURE(_pPointerToMember,
     115             :         "OPropertyContainerHelper::registerMayBeVoidProperty: you gave me nonsense : the pointer must be non-NULL");
     116             : 
     117       23914 :     _nAttributes |= PropertyAttribute::MAYBEVOID;
     118             : 
     119       23914 :     PropertyDescription aNewProp;
     120       23914 :     aNewProp.aProperty = Property( _rName, _nHandle, _rExpectedType, (sal_Int16)_nAttributes );
     121       23914 :     aNewProp.eLocated = PropertyDescription::ltDerivedClassAnyType;
     122       23914 :     aNewProp.aLocation.pDerivedClassMember = _pPointerToMember;
     123             : 
     124       23914 :     implPushBackProperty(aNewProp);
     125       23914 : }
     126             : 
     127             : 
     128             : 
     129       41220 : void OPropertyContainerHelper::registerPropertyNoMember(const OUString& _rName, sal_Int32 _nHandle, sal_Int32 _nAttributes,
     130             :         const Type& _rType, const void* _pInitialValue)
     131             : {
     132             :     OSL_ENSURE(!_rType.equals(cppu::UnoType<Any>::get()),
     133             :         "OPropertyContainerHelper::registerPropertyNoMember : don't give my the type of an uno::Any ! Really can't handle this !");
     134             :     OSL_ENSURE(_pInitialValue || ((_nAttributes & PropertyAttribute::MAYBEVOID) != 0),
     135             :         "OPropertyContainerHelper::registerPropertyNoMember : you should not omit the initial value if the property can't be void ! This will definitivly crash later !");
     136             : 
     137       41220 :     PropertyDescription aNewProp;
     138       41220 :     aNewProp.aProperty = Property( _rName, _nHandle, _rType, (sal_Int16)_nAttributes );
     139       41220 :     aNewProp.eLocated = PropertyDescription::ltHoldMyself;
     140       41220 :     aNewProp.aLocation.nOwnClassVectorIndex = m_aHoldProperties.size();
     141       41220 :     if (_pInitialValue)
     142       40578 :         m_aHoldProperties.push_back(Any(_pInitialValue, _rType));
     143             :     else
     144         642 :         m_aHoldProperties.push_back(Any());
     145             : 
     146       41220 :     implPushBackProperty(aNewProp);
     147       41220 : }
     148             : 
     149             : 
     150      687697 : bool OPropertyContainerHelper::isRegisteredProperty( sal_Int32 _nHandle ) const
     151             : {
     152      687697 :     return const_cast< OPropertyContainerHelper* >( this )->searchHandle( _nHandle ) != m_aProperties.end();
     153             : }
     154             : 
     155             : 
     156       35134 : bool OPropertyContainerHelper::isRegisteredProperty( const OUString& _rName ) const
     157             : {
     158             :     // TODO: the current structure is from a time where properties were
     159             :     // static, not dynamic. Since we allow that properties are also dynamic,
     160             :     // i.e. registered and revoked even though the XPropertySet has already been
     161             :     // accessed, a vector is not really the best data structure anymore ...
     162             : 
     163             :     ConstPropertiesIterator pos = ::std::find_if(
     164             :         m_aProperties.begin(),
     165             :         m_aProperties.end(),
     166             :         PropertyDescriptionNameMatch( _rName )
     167       35134 :     );
     168       35134 :     return pos != m_aProperties.end();
     169             : }
     170             : 
     171             : 
     172             : namespace
     173             : {
     174             :     struct ComparePropertyHandles
     175             :     {
     176      629074 :         bool operator()( const PropertyDescription& _rLHS, const PropertyDescription& _nRHS ) const
     177             :         {
     178      629074 :             return _rLHS.aProperty.Handle < _nRHS.aProperty.Handle;
     179             :         }
     180             :     };
     181             : }
     182             : 
     183             : 
     184      422249 : void OPropertyContainerHelper::implPushBackProperty(const PropertyDescription& _rProp)
     185             : {
     186             : #ifdef DBG_UTIL
     187             :     for (   PropertiesIterator checkConflicts = m_aProperties.begin();
     188             :             checkConflicts != m_aProperties.end();
     189             :             ++checkConflicts
     190             :         )
     191             :     {
     192             :         OSL_ENSURE(checkConflicts->aProperty.Name != _rProp.aProperty.Name, "OPropertyContainerHelper::implPushBackProperty: name already exists!");
     193             :         OSL_ENSURE(checkConflicts->aProperty.Handle != _rProp.aProperty.Handle, "OPropertyContainerHelper::implPushBackProperty: handle already exists!");
     194             :     }
     195             : #endif
     196             : 
     197             :     PropertiesIterator pos = ::std::lower_bound(
     198             :         m_aProperties.begin(), m_aProperties.end(),
     199      422249 :         _rProp, ComparePropertyHandles() );
     200             : 
     201      422249 :     m_aProperties.insert( pos, _rProp );
     202      422249 : }
     203             : 
     204             : 
     205             : namespace
     206             : {
     207          10 :     void lcl_throwIllegalPropertyValueTypeException( const PropertyDescription& _rProperty, const Any& _rValue )
     208             :     {
     209          10 :         OUStringBuffer aErrorMessage;
     210          10 :         aErrorMessage.appendAscii( "The given value cannot be converted to the required property type." );
     211          10 :         aErrorMessage.appendAscii( "\n(property name \"" );
     212          10 :         aErrorMessage.append( _rProperty.aProperty.Name );
     213          10 :         aErrorMessage.appendAscii( "\", found value type \"" );
     214          10 :         aErrorMessage.append( _rValue.getValueType().getTypeName() );
     215          10 :         aErrorMessage.appendAscii( "\", required property type \"" );
     216          10 :         aErrorMessage.append( _rProperty.aProperty.Type.getTypeName() );
     217          10 :         aErrorMessage.appendAscii( "\")" );
     218          10 :         throw IllegalArgumentException( aErrorMessage.makeStringAndClear(), NULL, 4 );
     219             :     }
     220             : }
     221             : 
     222             : 
     223       61454 : bool OPropertyContainerHelper::convertFastPropertyValue(
     224             :     Any& _rConvertedValue, Any& _rOldValue, sal_Int32 _nHandle, const Any& _rValue )
     225             : {
     226       61454 :     bool bModified = false;
     227             : 
     228             :     // get the property somebody is asking for
     229       61454 :     PropertiesIterator aPos = searchHandle(_nHandle);
     230       61454 :     if (aPos == m_aProperties.end())
     231             :     {
     232             :         OSL_FAIL( "OPropertyContainerHelper::convertFastPropertyValue: unknown handle!" );
     233             :         // should not happen if the derived class has built a correct property set info helper to be used by
     234             :         // our base class OPropertySetHelper
     235           0 :         return bModified;
     236             :     }
     237             : 
     238       61454 :     switch (aPos->eLocated)
     239             :     {
     240             :         // similar handling for the two cases where the value is stored in an any
     241             :         case PropertyDescription::ltHoldMyself:
     242             :         case PropertyDescription::ltDerivedClassAnyType:
     243             :         {
     244       15892 :             bool bMayBeVoid = ((aPos->aProperty.Attributes & PropertyAttribute::MAYBEVOID) != 0);
     245             : 
     246             : 
     247             :             // non modifiable version of the value-to-be-set
     248       15892 :             Any aNewRequestedValue( _rValue );
     249             : 
     250             :             // normalization
     251             :             // #i29490#
     252       15892 :             if ( !aNewRequestedValue.getValueType().equals( aPos->aProperty.Type ) )
     253             :             {   // the actually given value is not of the same type as the one required
     254       11696 :                 Any aProperlyTyped( NULL, aPos->aProperty.Type.getTypeLibType() );
     255             : 
     256       11696 :                 if (    uno_type_assignData(
     257       23392 :                             const_cast< void* >( aProperlyTyped.getValue() ), aProperlyTyped.getValueType().getTypeLibType(),
     258       23392 :                             const_cast< void* >( aNewRequestedValue.getValue() ), aNewRequestedValue.getValueType().getTypeLibType(),
     259             :                             reinterpret_cast< uno_QueryInterfaceFunc >( cpp_queryInterface ),
     260             :                             reinterpret_cast< uno_AcquireFunc >( cpp_acquire ),
     261             :                             reinterpret_cast< uno_ReleaseFunc >( cpp_release )
     262       35088 :                         )
     263             :                     )
     264             :                 {
     265             :                     // we were able to query the given XInterface-derivee for the interface
     266             :                     // which is required for this property
     267         496 :                     aNewRequestedValue = aProperlyTyped;
     268       11696 :                 }
     269             :             }
     270             : 
     271             :             // argument check
     272       45970 :             if  (   !   (   (bMayBeVoid && !aNewRequestedValue.hasValue())                      // void is allowed if the attribute says so
     273        4694 :                         ||  (aNewRequestedValue.getValueType().equals(aPos->aProperty.Type))    // else the types have to be equal
     274       20586 :                         )
     275             :                 )
     276             :             {
     277           2 :                 lcl_throwIllegalPropertyValueTypeException( *aPos, _rValue );
     278             :             }
     279             : 
     280       15890 :             Any* pPropContainer = NULL;
     281             :                 // the pointer to the any which holds the property value, no matter if located in the derived clas
     282             :                 // or in out vector
     283             : 
     284       15890 :             if (PropertyDescription::ltHoldMyself == aPos->eLocated)
     285             :             {
     286             :                 OSL_ENSURE(aPos->aLocation.nOwnClassVectorIndex < (sal_Int32)m_aHoldProperties.size(),
     287             :                     "OPropertyContainerHelper::convertFastPropertyValue: invalid position !");
     288        1818 :                 PropertyContainerIterator aIter = m_aHoldProperties.begin() + aPos->aLocation.nOwnClassVectorIndex;
     289        1818 :                 pPropContainer = &(*aIter);
     290             :             }
     291             :             else
     292       14072 :                 pPropContainer = reinterpret_cast<Any*>(aPos->aLocation.pDerivedClassMember);
     293             : 
     294             :             // check if the new value differs from the current one
     295       15890 :             if (!pPropContainer->hasValue() || !aNewRequestedValue.hasValue())
     296       13078 :                 bModified = pPropContainer->hasValue() != aNewRequestedValue.hasValue();
     297             :             else
     298             :                 bModified = !uno_type_equalData(
     299        5624 :                                 const_cast< void* >( pPropContainer->getValue() ), aPos->aProperty.Type.getTypeLibType(),
     300        5624 :                                 const_cast< void* >( aNewRequestedValue.getValue() ), aPos->aProperty.Type.getTypeLibType(),
     301             :                                 reinterpret_cast< uno_QueryInterfaceFunc >( cpp_queryInterface ),
     302             :                                 reinterpret_cast< uno_ReleaseFunc >( cpp_release )
     303        8436 :                             );
     304             : 
     305       15890 :             if (bModified)
     306             :             {
     307        2254 :                 _rOldValue = *pPropContainer;
     308        2254 :                 _rConvertedValue = aNewRequestedValue;
     309       15892 :             }
     310             :         }
     311       15890 :         break;
     312             :         case PropertyDescription::ltDerivedClassRealType:
     313             :             // let the UNO runtime library do any possible conversion
     314             :             // this may include a change of the type - for instance, if a LONG is required,
     315             :             // but a short is given, then this is valid, as it can be converted without any potential
     316             :             // data loss
     317             : 
     318       45562 :             Any aProperlyTyped;
     319       45562 :             const Any* pNewValue = &_rValue;
     320             : 
     321       45562 :             if (!_rValue.getValueType().equals(aPos->aProperty.Type))
     322             :             {
     323          12 :                 bool bConverted = false;
     324             : 
     325             :                 // a temporary any of the correct (required) type
     326          12 :                 aProperlyTyped = Any( NULL, aPos->aProperty.Type.getTypeLibType() );
     327             :                     // (need this as we do not want to overwrite the derived class member here)
     328             : 
     329          12 :                 if (    uno_type_assignData(
     330          24 :                             const_cast<void*>(aProperlyTyped.getValue()), aProperlyTyped.getValueType().getTypeLibType(),
     331          24 :                             const_cast<void*>(_rValue.getValue()), _rValue.getValueType().getTypeLibType(),
     332             :                             reinterpret_cast< uno_QueryInterfaceFunc >( cpp_queryInterface ),
     333             :                             reinterpret_cast< uno_AcquireFunc >( cpp_acquire ),
     334             :                             reinterpret_cast< uno_ReleaseFunc >( cpp_release )
     335          36 :                         )
     336             :                     )
     337             :                 {
     338             :                     // could query for the requested interface
     339           4 :                     bConverted = true;
     340           4 :                     pNewValue = &aProperlyTyped;
     341             :                 }
     342             : 
     343          12 :                 if ( !bConverted )
     344           8 :                     lcl_throwIllegalPropertyValueTypeException( *aPos, _rValue );
     345             :             }
     346             : 
     347             :             // from here on, we should have the proper type
     348             :             OSL_ENSURE( pNewValue->getValueType() == aPos->aProperty.Type,
     349             :                 "OPropertyContainerHelper::convertFastPropertyValue: conversion failed!" );
     350             :             bModified = !uno_type_equalData(
     351       91108 :                             aPos->aLocation.pDerivedClassMember, aPos->aProperty.Type.getTypeLibType(),
     352       91108 :                             const_cast<void*>(pNewValue->getValue()), aPos->aProperty.Type.getTypeLibType(),
     353             :                             reinterpret_cast< uno_QueryInterfaceFunc >( cpp_queryInterface ),
     354             :                             reinterpret_cast< uno_ReleaseFunc >( cpp_release )
     355      136662 :                         );
     356             : 
     357       45554 :             if (bModified)
     358             :             {
     359       19340 :                 _rOldValue.setValue(aPos->aLocation.pDerivedClassMember, aPos->aProperty.Type);
     360       19340 :                 _rConvertedValue = *pNewValue;
     361             :             }
     362       45562 :             break;
     363             :     }
     364             : 
     365       61444 :     return bModified;
     366             : }
     367             : 
     368             : 
     369       30645 : bool OPropertyContainerHelper::setFastPropertyValue(sal_Int32 _nHandle, const Any& _rValue)
     370             : {
     371             :     // get the property somebody is asking for
     372       30645 :     PropertiesIterator aPos = searchHandle(_nHandle);
     373       30645 :     if (aPos == m_aProperties.end())
     374             :     {
     375             :         OSL_FAIL( "OPropertyContainerHelper::setFastPropertyValue: unknown handle!" );
     376             :         // should not happen if the derived class has built a correct property set info helper to be used by
     377             :         // our base class OPropertySetHelper
     378           0 :         return false;
     379             :     }
     380             : 
     381       30645 :     bool bSuccess = true;
     382             : 
     383       30645 :     switch (aPos->eLocated)
     384             :     {
     385             :         case PropertyDescription::ltHoldMyself:
     386          54 :             m_aHoldProperties[aPos->aLocation.nOwnClassVectorIndex] = _rValue;
     387          54 :             break;
     388             : 
     389             :         case PropertyDescription::ltDerivedClassAnyType:
     390        2704 :             *reinterpret_cast< Any* >(aPos->aLocation.pDerivedClassMember) = _rValue;
     391        2704 :             break;
     392             : 
     393             :         case PropertyDescription::ltDerivedClassRealType:
     394             :             // copy the data from the to-be-set value
     395             :             bSuccess = uno_type_assignData(
     396       55774 :                 aPos->aLocation.pDerivedClassMember,        aPos->aProperty.Type.getTypeLibType(),
     397       55774 :                 const_cast< void* >( _rValue.getValue() ),  _rValue.getValueType().getTypeLibType(),
     398             :                 reinterpret_cast< uno_QueryInterfaceFunc >( cpp_queryInterface ),
     399             :                 reinterpret_cast< uno_AcquireFunc >( cpp_acquire ),
     400       83661 :                 reinterpret_cast< uno_ReleaseFunc >( cpp_release ) );
     401             : 
     402             :             OSL_ENSURE( bSuccess,
     403             :                 "OPropertyContainerHelper::setFastPropertyValue: ooops .... the value could not be assigned!");
     404             : 
     405       27887 :             break;
     406             :     }
     407             : 
     408       30645 :     return bSuccess;
     409             : }
     410             : 
     411      673000 : void OPropertyContainerHelper::getFastPropertyValue(Any& _rValue, sal_Int32 _nHandle) const
     412             : {
     413             :     // get the property somebody is asking for
     414      673000 :     PropertiesIterator aPos = const_cast<OPropertyContainerHelper*>(this)->searchHandle(_nHandle);
     415      673000 :     if (aPos == m_aProperties.end())
     416             :     {
     417             :         OSL_FAIL( "OPropertyContainerHelper::getFastPropertyValue: unknown handle!" );
     418             :         // should not happen if the derived class has built a correct property set info helper to be used by
     419             :         // our base class OPropertySetHelper
     420      673000 :         return;
     421             :     }
     422             : 
     423      673000 :     switch (aPos->eLocated)
     424             :     {
     425             :         case PropertyDescription::ltHoldMyself:
     426             :             OSL_ENSURE(aPos->aLocation.nOwnClassVectorIndex < (sal_Int32)m_aHoldProperties.size(),
     427             :                 "OPropertyContainerHelper::convertFastPropertyValue: invalid position !");
     428       70694 :             _rValue = m_aHoldProperties[aPos->aLocation.nOwnClassVectorIndex];
     429       70694 :             break;
     430             :         case PropertyDescription::ltDerivedClassAnyType:
     431       27390 :             _rValue = *reinterpret_cast<Any*>(aPos->aLocation.pDerivedClassMember);
     432       27390 :             break;
     433             :         case PropertyDescription::ltDerivedClassRealType:
     434      574916 :             _rValue.setValue(aPos->aLocation.pDerivedClassMember, aPos->aProperty.Type);
     435      574916 :             break;
     436             :     }
     437             : }
     438             : 
     439             : 
     440     1452840 : OPropertyContainerHelper::PropertiesIterator OPropertyContainerHelper::searchHandle(sal_Int32 _nHandle)
     441             : {
     442     1452840 :     PropertyDescription aHandlePropDesc;
     443     1452840 :     aHandlePropDesc.aProperty.Handle = _nHandle;
     444             :     // search a lower bound
     445             :     PropertiesIterator aLowerBound = ::std::lower_bound(
     446             :         m_aProperties.begin(),
     447             :         m_aProperties.end(),
     448             :         aHandlePropDesc,
     449     1452840 :         PropertyDescriptionHandleCompare());
     450             : 
     451             :     // check for identity
     452     1452840 :     if ((aLowerBound != m_aProperties.end()) && aLowerBound->aProperty.Handle != _nHandle)
     453       63222 :         aLowerBound = m_aProperties.end();
     454             : 
     455     1452840 :     return aLowerBound;
     456             : }
     457             : 
     458             : 
     459          48 : const Property& OPropertyContainerHelper::getProperty( const OUString& _rName ) const
     460             : {
     461             :     ConstPropertiesIterator pos = ::std::find_if(
     462             :         m_aProperties.begin(),
     463             :         m_aProperties.end(),
     464             :         PropertyDescriptionNameMatch( _rName )
     465          48 :     );
     466          48 :     if ( pos == m_aProperties.end() )
     467           2 :         throw UnknownPropertyException( _rName );
     468             : 
     469          46 :     return pos->aProperty;
     470             : }
     471             : 
     472             : 
     473        9621 : void OPropertyContainerHelper::describeProperties(Sequence< Property >& _rProps) const
     474             : {
     475        9621 :     Sequence< Property > aOwnProps(m_aProperties.size());
     476        9621 :     Property* pOwnProps = aOwnProps.getArray();
     477             : 
     478      258792 :     for (   ConstPropertiesIterator aLoop = m_aProperties.begin();
     479      172528 :             aLoop != m_aProperties.end();
     480             :             ++aLoop, ++pOwnProps
     481             :         )
     482             :     {
     483       76643 :         pOwnProps->Name = aLoop->aProperty.Name;
     484       76643 :         pOwnProps->Handle = aLoop->aProperty.Handle;
     485       76643 :         pOwnProps->Attributes = (sal_Int16)aLoop->aProperty.Attributes;
     486       76643 :         pOwnProps->Type = aLoop->aProperty.Type;
     487             :     }
     488             : 
     489             :     // as our property vector is sorted by handles, not by name, we have to sort aOwnProps
     490        9621 :     ::std::sort(aOwnProps.getArray(), aOwnProps.getArray() + aOwnProps.getLength(), PropertyCompareByName());
     491             : 
     492             :     // unfortunately the STL merge function does not allow the output range to overlap one of the input ranges,
     493             :     // so we need an extra sequence
     494       19242 :     Sequence< Property > aOutput;
     495        9621 :     aOutput.realloc(_rProps.getLength() + aOwnProps.getLength());
     496             :     // do the merge
     497        9621 :     ::std::merge(   _rProps.getConstArray(), _rProps.getConstArray() + _rProps.getLength(),         // input 1
     498        9621 :                     aOwnProps.getConstArray(), aOwnProps.getConstArray() + aOwnProps.getLength(),   // input 2
     499             :                     aOutput.getArray(),                                                             // output
     500             :                     PropertyCompareByName()                                                         // compare operator
     501       28863 :                 );
     502             : 
     503             :     // copy the output
     504       19242 :     _rProps = aOutput;
     505        9621 : }
     506             : 
     507             : 
     508             : }   // namespace comphelper
     509             : 
     510             : 
     511             : 
     512             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10