comphelper/source/property/opropertybag.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include "opropertybag.hxx"
  22
  23 #include <com/sun/star/beans/IllegalTypeException.hpp>
  24 #include <com/sun/star/beans/PropertyAttribute.hpp>
  25 #include <com/sun/star/beans/Property.hpp>
  26
  27 #include <comphelper/namedvaluecollection.hxx>
  28 #include <cppuhelper/supportsservice.hxx>
  29
  30 #include <cppuhelper/exc_hlp.hxx>
  31
  32 #include <algorithm>
  33 #include <iterator>
  34
  35 namespace com::sun::star::uno { class XComponentContext; }
  36
  37 using namespace ::com::sun::star;
  38
  39 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
  40 com_sun_star_comp_comphelper_OPropertyBag (
  41     css::uno::XComponentContext *,
  42     css::uno::Sequence<css::uno::Any> const &)
  43 {
  44     return cppu::acquire(new comphelper::OPropertyBag());
  45 }
  46
  47 namespace comphelper
  48 {
  49
  50
  51     using namespace ::com::sun::star::uno;
  52     using namespace ::com::sun::star::lang;
  53     using namespace ::com::sun::star::beans;
  54     using namespace ::com::sun::star::util;
  55     using namespace ::com::sun::star::container;
  56
  57     OPropertyBag::OPropertyBag()
  58         :OPropertyBag_PBase( GetBroadcastHelper(), this )
  59         ,::cppu::IEventNotificationHook()
  60         ,m_bAutoAddProperties( false )
  61         ,m_NotifyListeners(m_aMutex)
  62         ,m_isModified(false)
  63
  64     {
  65     }
  66
  67
  68     OPropertyBag::~OPropertyBag()
  69     {
  70     }
  71
  72
  73     IMPLEMENT_FORWARD_XINTERFACE2( OPropertyBag, OPropertyBag_Base, OPropertyBag_PBase )
  74     IMPLEMENT_FORWARD_XTYPEPROVIDER2( OPropertyBag, OPropertyBag_Base, OPropertyBag_PBase )
  75
  76     void SAL_CALL OPropertyBag::initialize( const Sequence< Any >& _rArguments )
  77     {
  78         Sequence< Type > aTypes;
  79         bool AllowEmptyPropertyName(false);
  80         bool AutomaticAddition(false);
  81
  82         if (_rArguments.getLength() == 3
  83            && (_rArguments[0] >>= aTypes)
  84            && (_rArguments[1] >>= AllowEmptyPropertyName)
  85            && (_rArguments[2] >>= AutomaticAddition))
  86         {
  87             std::copy(
  88                 aTypes.begin(),
  89                 aTypes.end(),
  90                 std::insert_iterator< TypeBag >( m_aAllowedTypes, m_aAllowedTypes.begin() )
  91             );
  92             m_bAutoAddProperties = AutomaticAddition;
  93
  94         } else {
  95             ::comphelper::NamedValueCollection aArguments( _rArguments );
  96
  97             if ( aArguments.get_ensureType( "AllowedTypes", aTypes ) )
  98                 std::copy(
  99                     aTypes.begin(),
 100                     aTypes.end(),
 101                     std::insert_iterator< TypeBag >( m_aAllowedTypes, m_aAllowedTypes.begin() )
 102                 );
 103
 104             aArguments.get_ensureType( "AutomaticAddition", m_bAutoAddProperties );
 105             aArguments.get_ensureType( "AllowEmptyPropertyName",
 106                 AllowEmptyPropertyName );
 107         }
 108         if (AllowEmptyPropertyName) {
 109             m_aDynamicProperties.setAllowEmptyPropertyName(
 110                 AllowEmptyPropertyName);
 111         }
 112     }
 113
 114     OUString SAL_CALL OPropertyBag::getImplementationName()
 115     {
 116         return OUString( "com.sun.star.comp.comphelper.OPropertyBag" );
 117     }
 118
 119     sal_Bool SAL_CALL OPropertyBag::supportsService( const OUString& rServiceName )
 120     {
 121         return cppu::supportsService(this, rServiceName);
 122     }
 123
 124     Sequence< OUString > SAL_CALL OPropertyBag::getSupportedServiceNames(  )
 125     {
 126          return { "com.sun.star.beans.PropertyBag" };
 127     }
 128
 129     void OPropertyBag::fireEvents(
 130             sal_Int32 * /*pnHandles*/,
 131             sal_Int32 nCount,
 132             sal_Bool bVetoable,
 133             bool bIgnoreRuntimeExceptionsWhileFiring)
 134     {
 135         if (nCount && !bVetoable) {
 136             setModifiedImpl(true, bIgnoreRuntimeExceptionsWhileFiring);
 137         }
 138     }
 139
 140     void OPropertyBag::setModifiedImpl(bool bModified,
 141             bool bIgnoreRuntimeExceptionsWhileFiring)
 142     {
 143         { // do not lock mutex while notifying (#i93514#) to prevent deadlock
 144             ::osl::MutexGuard aGuard( m_aMutex );
 145             m_isModified = bModified;
 146         }
 147         if (bModified) {
 148             try {
 149                 Reference<XInterface> xThis(*this);
 150                 EventObject event(xThis);
 151                 m_NotifyListeners.notifyEach(
 152                     &XModifyListener::modified, event);
 153             } catch (RuntimeException &) {
 154                 if (!bIgnoreRuntimeExceptionsWhileFiring) {
 155                     throw;
 156                 }
 157             } catch (Exception &) {
 158                 // ignore
 159             }
 160         }
 161     }
 162
 163
 164     sal_Bool SAL_CALL OPropertyBag::isModified()
 165     {
 166         ::osl::MutexGuard aGuard( m_aMutex );
 167         return m_isModified;
 168     }
 169
 170     void SAL_CALL OPropertyBag::setModified( sal_Bool bModified )
 171     {
 172         setModifiedImpl(bModified, false);
 173     }
 174
 175     void SAL_CALL OPropertyBag::addModifyListener(
 176         const Reference< XModifyListener > & xListener)
 177     {
 178         m_NotifyListeners.addInterface(xListener);
 179     }
 180
 181     void SAL_CALL OPropertyBag::removeModifyListener(
 182         const Reference< XModifyListener > & xListener)
 183     {
 184         m_NotifyListeners.removeInterface(xListener);
 185     }
 186
 187
 188     Reference< XPropertySetInfo > SAL_CALL OPropertyBag::getPropertySetInfo(  )
 189     {
 190         return createPropertySetInfo( getInfoHelper() );
 191     }
 192
 193
 194     sal_Bool SAL_CALL OPropertyBag::has( const Any& /*aElement*/ )
 195     {
 196         // XSet is only a workaround for addProperty not being able to add default-void properties.
 197         // So, everything of XSet except insert is implemented empty
 198         return false;
 199     }
 200
 201
 202     void SAL_CALL OPropertyBag::insert( const Any& _element )
 203     {
 204         // This is a workaround for addProperty not being able to add default-void properties.
 205         // If we ever have a smarter XPropertyContainer::addProperty interface, we can remove this, ehm, well, hack.
 206         Property aProperty;
 207         if ( !( _element >>= aProperty ) )
 208             throw IllegalArgumentException( OUString(), *this, 1 );
 209
 210         {
 211             osl::MutexGuard g(m_aMutex);
 212
 213             // check whether the type is allowed, everything else will be checked
 214             // by m_aDynamicProperties
 215             if (!m_aAllowedTypes.empty()
 216                 && m_aAllowedTypes.find(aProperty.Type) == m_aAllowedTypes.end())
 217                 throw IllegalArgumentException(OUString(), *this, 1);
 218
 219             m_aDynamicProperties.addVoidProperty(aProperty.Name, aProperty.Type, findFreeHandle(),
 220                                                  aProperty.Attributes);
 221
 222             // our property info is dirty
 223             m_pArrayHelper.reset();
 224         }
 225         setModified(true);
 226     }
 227
 228
 229     void SAL_CALL OPropertyBag::remove( const Any& /*aElement*/ )
 230     {
 231         // XSet is only a workaround for addProperty not being able to add default-void properties.
 232         // So, everything of XSet except insert is implemented empty
 233         throw NoSuchElementException( OUString(), *this );
 234     }
 235
 236
 237     Reference< XEnumeration > SAL_CALL OPropertyBag::createEnumeration(  )
 238     {
 239         // XSet is only a workaround for addProperty not being able to add default-void properties.
 240         // So, everything of XSet except insert is implemented empty
 241         return nullptr;
 242     }
 243
 244
 245     Type SAL_CALL OPropertyBag::getElementType(  )
 246     {
 247         // XSet is only a workaround for addProperty not being able to add default-void properties.
 248         // So, everything of XSet except insert is implemented empty
 249         return Type();
 250     }
 251
 252
 253     sal_Bool SAL_CALL OPropertyBag::hasElements(  )
 254     {
 255         // XSet is only a workaround for addProperty not being able to add default-void properties.
 256         // So, everything of XSet except insert is implemented empty
 257         return false;
 258     }
 259
 260
 261     void SAL_CALL OPropertyBag::getFastPropertyValue( Any& _rValue, sal_Int32 _nHandle ) const
 262     {
 263         m_aDynamicProperties.getFastPropertyValue( _nHandle, _rValue );
 264     }
 265
 266     sal_Bool SAL_CALL OPropertyBag::convertFastPropertyValue( Any& _rConvertedValue, Any& _rOldValue, sal_Int32 _nHandle, const Any& _rValue )
 267     {
 268         return m_aDynamicProperties.convertFastPropertyValue( _nHandle, _rValue, _rConvertedValue, _rOldValue );
 269     }
 270
 271     void SAL_CALL OPropertyBag::setFastPropertyValue_NoBroadcast( sal_Int32 nHandle, const Any& rValue )
 272     {
 273         m_aDynamicProperties.setFastPropertyValue( nHandle, rValue );
 274     }
 275
 276
 277     ::cppu::IPropertyArrayHelper& SAL_CALL OPropertyBag::getInfoHelper()
 278     {
 279         if (!m_pArrayHelper)
 280         {
 281             Sequence< Property > aProperties;
 282             m_aDynamicProperties.describeProperties( aProperties );
 283             m_pArrayHelper.reset( new ::cppu::OPropertyArrayHelper( aProperties ) );
 284         }
 285         return *m_pArrayHelper;
 286
 287     }
 288
 289
 290     sal_Int32 OPropertyBag::findFreeHandle() const
 291     {
 292         const sal_Int32 nPrime = 1009;
 293         const sal_Int32 nSeed = 11;
 294
 295         sal_Int32 nCheck = nSeed;
 296         while ( m_aDynamicProperties.hasPropertyByHandle( nCheck ) && ( nCheck != 1 ) )
 297         {
 298             nCheck = ( nCheck * nSeed ) % nPrime;
 299         }
 300
 301         if ( nCheck == 1 )
 302         {   // uh ... we already have 1008 handles used up
 303             // -> simply count upwards
 304             while ( m_aDynamicProperties.hasPropertyByHandle( nCheck ) )
 305                 ++nCheck;
 306         }
 307
 308         return nCheck;
 309     }
 310
 311
 312     void SAL_CALL OPropertyBag::addProperty( const OUString& _rName, ::sal_Int16 _nAttributes, const Any& _rInitialValue )
 313     {
 314         {
 315             osl::MutexGuard g(m_aMutex);
 316
 317             // check whether the type is allowed, everything else will be checked
 318             // by m_aDynamicProperties
 319             const Type& aPropertyType = _rInitialValue.getValueType();
 320             if (_rInitialValue.hasValue() && !m_aAllowedTypes.empty()
 321                 && m_aAllowedTypes.find(aPropertyType) == m_aAllowedTypes.end())
 322                 throw IllegalTypeException(OUString(), *this);
 323
 324             m_aDynamicProperties.addProperty(_rName, findFreeHandle(), _nAttributes,
 325                                              _rInitialValue);
 326
 327             // our property info is dirty
 328             m_pArrayHelper.reset();
 329         }
 330         setModified(true);
 331     }
 332
 333
 334     void SAL_CALL OPropertyBag::removeProperty( const OUString& _rName )
 335     {
 336         {
 337             osl::MutexGuard g(m_aMutex);
 338
 339             m_aDynamicProperties.removeProperty(_rName);
 340
 341             // our property info is dirty
 342             m_pArrayHelper.reset();
 343         }
 344         setModified(true);
 345     }
 346
 347
 348     namespace
 349     {
 350         struct ComparePropertyValueByName
 351         {
 352             bool operator()( const PropertyValue& _rLHS, const PropertyValue& _rRHS )
 353             {
 354                 return _rLHS.Name < _rRHS.Name;
 355             }
 356         };
 357
 358         template< typename CLASS >
 359         struct TransformPropertyToName
 360         {
 361             const OUString& operator()( const CLASS& _rProp )
 362             {
 363                 return _rProp.Name;
 364             }
 365         };
 366
 367         struct ExtractPropertyValue
 368         {
 369             const Any& operator()( const PropertyValue& _rProp )
 370             {
 371                 return _rProp.Value;
 372             }
 373         };
 374     }
 375
 376
 377     Sequence< PropertyValue > SAL_CALL OPropertyBag::getPropertyValues(  )
 378     {
 379         ::osl::MutexGuard aGuard( m_aMutex );
 380
 381         // all registered properties
 382         Sequence< Property > aProperties;
 383         m_aDynamicProperties.describeProperties( aProperties );
 384
 385         // their names
 386         Sequence< OUString > aNames( aProperties.getLength() );
 387         std::transform(
 388             aProperties.begin(),
 389             aProperties.end(),
 390             aNames.getArray(),
 391             TransformPropertyToName< Property >()
 392         );
 393
 394         // their values
 395         Sequence< Any > aValues;
 396         try
 397         {
 398             aValues = OPropertyBag_PBase::getPropertyValues( aNames );
 399             if ( aValues.getLength() != aNames.getLength() )
 400                 throw RuntimeException();
 401         }
 402         catch( const RuntimeException& )
 403         {
 404             throw;
 405         }
 406         catch( const Exception& )
 407         {
 408             // ignore
 409         }
 410
 411         // merge names and values, and retrieve the state/handle
 412         ::cppu::IPropertyArrayHelper& rPropInfo = getInfoHelper();
 413
 414         Sequence< PropertyValue > aPropertyValues( aNames.getLength() );
 415         const OUString* pName = aNames.getConstArray();
 416         const OUString* pNamesEnd = aNames.getConstArray() + aNames.getLength();
 417         const Any* pValue = aValues.getArray();
 418         PropertyValue* pPropertyValue = aPropertyValues.getArray();
 419
 420         for ( ; pName != pNamesEnd; ++pName, ++pValue, ++pPropertyValue )
 421         {
 422             pPropertyValue->Name = *pName;
 423             pPropertyValue->Handle = rPropInfo.getHandleByName( *pName );
 424             pPropertyValue->Value = *pValue;
 425             pPropertyValue->State = getPropertyStateByHandle( pPropertyValue->Handle );
 426         }
 427
 428         return aPropertyValues;
 429     }
 430
 431
 432     void OPropertyBag::impl_setPropertyValues_throw( const Sequence< PropertyValue >& _rProps )
 433     {
 434         // sort (the XMultiPropertySet interface requires this)
 435         Sequence< PropertyValue > aProperties( _rProps );
 436         std::sort(
 437             aProperties.begin(),
 438             aProperties.end(),
 439             ComparePropertyValueByName()
 440         );
 441
 442         // a sequence of names
 443         Sequence< OUString > aNames( aProperties.getLength() );
 444         std::transform(
 445             aProperties.begin(),
 446             aProperties.end(),
 447             aNames.getArray(),
 448             TransformPropertyToName< PropertyValue >()
 449         );
 450
 451         try
 452         {
 453             // check for unknown properties
 454             // we cannot simply rely on the XMultiPropertySet::setPropertyValues
 455             // implementation of our base class, since it does not throw
 456             // an UnknownPropertyException. More precise, XMultiPropertySet::setPropertyValues
 457             // does not allow to throw this exception, while XPropertyAccess::setPropertyValues
 458             // requires it
 459             sal_Int32 nCount = aNames.getLength();
 460
 461             Sequence< sal_Int32 > aHandles( nCount );
 462             sal_Int32* pHandle = aHandles.getArray();
 463             const PropertyValue* pProperty = aProperties.getConstArray();
 464             for (   const OUString* pName = aNames.getConstArray();
 465                     pName != aNames.getConstArray() + aNames.getLength();
 466                     ++pName, ++pHandle, ++pProperty
 467                 )
 468             {
 469                 ::cppu::IPropertyArrayHelper& rPropInfo = getInfoHelper();
 470                 *pHandle = rPropInfo.getHandleByName( *pName );
 471                 if ( *pHandle != -1 )
 472                     continue;
 473
 474                 // there's a property requested which we do not know
 475                 if ( m_bAutoAddProperties )
 476                 {
 477                     // add the property
 478                     sal_Int16 const nAttributes = PropertyAttribute::BOUND | PropertyAttribute::REMOVABLE | PropertyAttribute::MAYBEDEFAULT;
 479                     addProperty( *pName, nAttributes, pProperty->Value );
 480                     continue;
 481                 }
 482
 483                 // no way out
 484                 throw UnknownPropertyException( *pName, *this );
 485             }
 486
 487             // a sequence of values
 488             Sequence< Any > aValues( aProperties.getLength() );
 489             std::transform(
 490                 aProperties.begin(),
 491                 aProperties.end(),
 492                 aValues.getArray(),
 493                 ExtractPropertyValue()
 494             );
 495
 496             setFastPropertyValues( nCount, aHandles.getArray(), aValues.getConstArray(), nCount );
 497         }
 498         catch( const PropertyVetoException& )       { throw; }
 499         catch( const IllegalArgumentException& )    { throw; }
 500         catch( const WrappedTargetException& )      { throw; }
 501         catch( const RuntimeException& )            { throw; }
 502         catch( const UnknownPropertyException& )    { throw; }
 503         catch( const Exception& )
 504         {
 505             throw WrappedTargetException( OUString(), *this, ::cppu::getCaughtException() );
 506         }
 507     }
 508
 509
 510     void SAL_CALL OPropertyBag::setPropertyValues( const Sequence< PropertyValue >& _rProps )
 511     {
 512         ::osl::MutexGuard aGuard( m_aMutex );
 513         impl_setPropertyValues_throw( _rProps );
 514     }
 515
 516
 517     PropertyState OPropertyBag::getPropertyStateByHandle( sal_Int32 _nHandle )
 518     {
 519         // for properties which do not support the MAYBEDEFAULT attribute, don't rely on the base class, but
 520         // assume they're always in DIRECT state.
 521         // (Note that this probably would belong into the base class. However, this would mean we would need
 522         // to check all existent usages of the base class, where MAYBEDEFAULT is *not* set, but
 523         // a default is nonetheless supplied/used. This is hard to accomplish reliably, in the
 524         // current phase. #i78593#
 525
 526         ::cppu::IPropertyArrayHelper& rPropInfo = getInfoHelper();
 527         sal_Int16 nAttributes(0);
 528         OSL_VERIFY( rPropInfo.fillPropertyMembersByHandle( nullptr, &nAttributes, _nHandle ) );
 529         if ( ( nAttributes & PropertyAttribute::MAYBEDEFAULT ) == 0 )
 530             return PropertyState_DIRECT_VALUE;
 531
 532         return OPropertyBag_PBase::getPropertyStateByHandle( _nHandle );
 533     }
 534
 535
 536     Any OPropertyBag::getPropertyDefaultByHandle( sal_Int32 _nHandle ) const
 537     {
 538         Any aDefault;
 539         m_aDynamicProperties.getPropertyDefaultByHandle( _nHandle, aDefault );
 540         return aDefault;
 541     }
 542
 543
 544 }   // namespace comphelper
 545
 546
 547 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */