comphelper/source/property/MasterPropertySet.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 <comphelper/MasterPropertySet.hxx>
  22 #include <comphelper/MasterPropertySetInfo.hxx>
  23 #include <comphelper/ChainablePropertySet.hxx>
  24 #include <comphelper/ChainablePropertySetInfo.hxx>
  25 #include <comphelper/solarmutex.hxx>
  26
  27 #include <boost/scoped_ptr.hpp>
  28
  29
  30
  31 class AutoOGuardArray
  32 {
  33     boost::scoped_ptr< osl::Guard< comphelper::SolarMutex > > *  mpGuardArray;
  34
  35 public:
  36     AutoOGuardArray( sal_Int32 nNumElements );
  37     ~AutoOGuardArray();
  38
  39     boost::scoped_ptr< osl::Guard< comphelper::SolarMutex > > &  operator[] ( sal_Int32 i ) { return mpGuardArray[i]; }
  40 };
  41
  42 AutoOGuardArray::AutoOGuardArray( sal_Int32 nNumElements ) : mpGuardArray(new boost::scoped_ptr< osl::Guard< comphelper::SolarMutex > >[nNumElements])
  43 {
  44 }
  45
  46 AutoOGuardArray::~AutoOGuardArray()
  47 {
  48     //!! release auto_ptr's and thus the mutexes locks
  49     delete [] mpGuardArray;
  50
  51 }
  52
  53
  54
  55 using namespace ::comphelper;
  56 using namespace ::com::sun::star;
  57 using namespace ::com::sun::star::uno;
  58 using namespace ::com::sun::star::lang;
  59 using namespace ::com::sun::star::beans;
  60
  61
  62 SlaveData::SlaveData ( ChainablePropertySet *pSlave)
  63 : mpSlave ( pSlave )
  64 , mxSlave ( pSlave )
  65 , mbInit ( false )
  66 {
  67 }
  68
  69 MasterPropertySet::MasterPropertySet( comphelper::MasterPropertySetInfo* pInfo, comphelper::SolarMutex* pMutex )
  70     throw()
  71 : mpInfo ( pInfo )
  72 , mpMutex ( pMutex )
  73 , mnLastId ( 0 )
  74 , mxInfo ( pInfo )
  75 {
  76 }
  77
  78 MasterPropertySet::~MasterPropertySet()
  79     throw()
  80 {
  81     SlaveMap::iterator aEnd = maSlaveMap.end(), aIter = maSlaveMap.begin();
  82     while (aIter != aEnd )
  83     {
  84         delete (*aIter).second;
  85         ++aIter;
  86     }
  87 }
  88
  89 // XPropertySet
  90 Reference< XPropertySetInfo > SAL_CALL MasterPropertySet::getPropertySetInfo(  )
  91     throw(RuntimeException, std::exception)
  92 {
  93     return mxInfo;
  94 }
  95
  96 void MasterPropertySet::registerSlave ( ChainablePropertySet *pNewSet )
  97     throw()
  98 {
  99     maSlaveMap [ ++mnLastId ] = new SlaveData ( pNewSet );
 100     mpInfo->add ( pNewSet->mpInfo->maMap, mnLastId );
 101 }
 102
 103 void SAL_CALL MasterPropertySet::setPropertyValue( const OUString& rPropertyName, const Any& rValue )
 104     throw(UnknownPropertyException, PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException, std::exception)
 105 {
 106     // acquire mutex in c-tor and releases it in the d-tor (exception safe!).
 107     boost::scoped_ptr< osl::Guard< comphelper::SolarMutex > > pMutexGuard;
 108     if (mpMutex)
 109         pMutexGuard.reset( new osl::Guard< comphelper::SolarMutex >(mpMutex) );
 110
 111     PropertyDataHash::const_iterator aIter = mpInfo->maMap.find ( rPropertyName );
 112
 113     if( aIter == mpInfo->maMap.end())
 114         throw UnknownPropertyException( rPropertyName, static_cast< XPropertySet* >( this ) );
 115
 116     if ( (*aIter).second->mnMapId == 0 ) // 0 means it's one of ours !
 117     {
 118         _preSetValues();
 119         _setSingleValue( *((*aIter).second->mpInfo), rValue );
 120         _postSetValues();
 121     }
 122     else
 123     {
 124         ChainablePropertySet * pSlave = maSlaveMap [ (*aIter).second->mnMapId ]->mpSlave;
 125
 126         // acquire mutex in c-tor and releases it in the d-tor (exception safe!).
 127         boost::scoped_ptr< osl::Guard< comphelper::SolarMutex > > pMutexGuard2;
 128         if (pSlave->mpMutex)
 129             pMutexGuard2.reset( new osl::Guard< comphelper::SolarMutex >(pSlave->mpMutex) );
 130
 131         pSlave->_preSetValues();
 132         pSlave->_setSingleValue( *((*aIter).second->mpInfo), rValue );
 133         pSlave->_postSetValues();
 134     }
 135 }
 136
 137 Any SAL_CALL MasterPropertySet::getPropertyValue( const OUString& rPropertyName )
 138     throw(UnknownPropertyException, WrappedTargetException, RuntimeException, std::exception)
 139 {
 140     // acquire mutex in c-tor and releases it in the d-tor (exception safe!).
 141     boost::scoped_ptr< osl::Guard< comphelper::SolarMutex > > pMutexGuard;
 142     if (mpMutex)
 143         pMutexGuard.reset( new osl::Guard< comphelper::SolarMutex >(mpMutex) );
 144
 145     PropertyDataHash::const_iterator aIter = mpInfo->maMap.find ( rPropertyName );
 146
 147     if( aIter == mpInfo->maMap.end())
 148         throw UnknownPropertyException( rPropertyName, static_cast< XPropertySet* >( this ) );
 149
 150     Any aAny;
 151     if ( (*aIter).second->mnMapId == 0 ) // 0 means it's one of ours !
 152     {
 153         _preGetValues();
 154         _getSingleValue( *((*aIter).second->mpInfo), aAny );
 155         _postGetValues();
 156     }
 157     else
 158     {
 159         ChainablePropertySet * pSlave = maSlaveMap [ (*aIter).second->mnMapId ]->mpSlave;
 160
 161         // acquire mutex in c-tor and releases it in the d-tor (exception safe!).
 162         boost::scoped_ptr< osl::Guard< comphelper::SolarMutex > > pMutexGuard2;
 163         if (pSlave->mpMutex)
 164             pMutexGuard2.reset( new osl::Guard< comphelper::SolarMutex >(pSlave->mpMutex) );
 165
 166         pSlave->_preGetValues();
 167         pSlave->_getSingleValue( *((*aIter).second->mpInfo), aAny );
 168         pSlave->_postGetValues();
 169     }
 170     return aAny;
 171 }
 172
 173 void SAL_CALL MasterPropertySet::addPropertyChangeListener( const OUString&, const Reference< XPropertyChangeListener >& )
 174     throw(UnknownPropertyException, WrappedTargetException, RuntimeException, std::exception)
 175 {
 176     // todo
 177 }
 178
 179 void SAL_CALL MasterPropertySet::removePropertyChangeListener( const OUString&, const Reference< XPropertyChangeListener >& )
 180     throw(UnknownPropertyException, WrappedTargetException, RuntimeException, std::exception)
 181 {
 182     // todo
 183 }
 184
 185 void SAL_CALL MasterPropertySet::addVetoableChangeListener( const OUString&, const Reference< XVetoableChangeListener >& )
 186     throw(UnknownPropertyException, WrappedTargetException, RuntimeException, std::exception)
 187 {
 188     // todo
 189 }
 190
 191 void SAL_CALL MasterPropertySet::removeVetoableChangeListener( const OUString&, const Reference< XVetoableChangeListener >& )
 192     throw(UnknownPropertyException, WrappedTargetException, RuntimeException, std::exception)
 193 {
 194     // todo
 195 }
 196
 197 // XMultiPropertySet
 198 void SAL_CALL MasterPropertySet::setPropertyValues( const Sequence< OUString >& aPropertyNames, const Sequence< Any >& aValues )
 199     throw(PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException, std::exception)
 200 {
 201     // acquire mutex in c-tor and releases it in the d-tor (exception safe!).
 202     boost::scoped_ptr< osl::Guard< comphelper::SolarMutex > > pMutexGuard;
 203     if (mpMutex)
 204         pMutexGuard.reset( new osl::Guard< comphelper::SolarMutex >(mpMutex) );
 205
 206     const sal_Int32 nCount = aPropertyNames.getLength();
 207
 208     if( nCount != aValues.getLength() )
 209         throw IllegalArgumentException();
 210
 211     if( nCount )
 212     {
 213         _preSetValues();
 214
 215         const Any * pAny = aValues.getConstArray();
 216         const OUString * pString = aPropertyNames.getConstArray();
 217         PropertyDataHash::const_iterator aEnd = mpInfo->maMap.end(), aIter;
 218
 219         //!! have an auto_ptr to an array of OGuards in order to have the
 220         //!! allocated memory properly freed (exception safe!).
 221         //!! Since the array itself has auto_ptrs as members we have to use a
 222         //!! helper class 'AutoOGuardArray' in order to have
 223         //!! the acquired locks properly released.
 224         AutoOGuardArray aOGuardArray( nCount );
 225
 226         for ( sal_Int32 i = 0; i < nCount; ++i, ++pString, ++pAny )
 227         {
 228             aIter = mpInfo->maMap.find ( *pString );
 229             if ( aIter == aEnd )
 230                 throw UnknownPropertyException( *pString, static_cast< XPropertySet* >( this ) );
 231
 232             if ( (*aIter).second->mnMapId == 0 ) // 0 means it's one of ours !
 233                 _setSingleValue( *((*aIter).second->mpInfo), *pAny );
 234             else
 235             {
 236                 SlaveData * pSlave = maSlaveMap [ (*aIter).second->mnMapId ];
 237                 if (!pSlave->IsInit())
 238                 {
 239                     // acquire mutex in c-tor and releases it in the d-tor (exception safe!).
 240                     if (pSlave->mpSlave->mpMutex)
 241                         aOGuardArray[i].reset( new osl::Guard< comphelper::SolarMutex >(pSlave->mpSlave->mpMutex) );
 242
 243                     pSlave->mpSlave->_preSetValues();
 244                     pSlave->SetInit ( true );
 245                 }
 246                 pSlave->mpSlave->_setSingleValue( *((*aIter).second->mpInfo), *pAny );
 247             }
 248         }
 249
 250         _postSetValues();
 251         SlaveMap::const_iterator aSlaveIter = maSlaveMap.begin(), aSlaveEnd = maSlaveMap.end();
 252         while (aSlaveIter != aSlaveEnd)
 253         {
 254             if ( (*aSlaveIter).second->IsInit())
 255             {
 256                 (*aSlaveIter).second->mpSlave->_postSetValues();
 257                 (*aSlaveIter).second->SetInit ( false );
 258             }
 259             ++aSlaveIter;
 260         }
 261     }
 262 }
 263
 264 Sequence< Any > SAL_CALL MasterPropertySet::getPropertyValues( const Sequence< OUString >& aPropertyNames )
 265     throw(RuntimeException, std::exception)
 266 {
 267     // acquire mutex in c-tor and releases it in the d-tor (exception safe!).
 268     boost::scoped_ptr< osl::Guard< comphelper::SolarMutex > > pMutexGuard;
 269     if (mpMutex)
 270         pMutexGuard.reset( new osl::Guard< comphelper::SolarMutex >(mpMutex) );
 271
 272     const sal_Int32 nCount = aPropertyNames.getLength();
 273
 274     Sequence < Any > aValues ( nCount );
 275
 276     if( nCount )
 277     {
 278         _preGetValues();
 279
 280         Any * pAny = aValues.getArray();
 281         const OUString * pString = aPropertyNames.getConstArray();
 282         PropertyDataHash::const_iterator aEnd = mpInfo->maMap.end(), aIter;
 283
 284         //!! have an auto_ptr to an array of OGuards in order to have the
 285         //!! allocated memory properly freed (exception safe!).
 286         //!! Since the array itself has auto_ptrs as members we have to use a
 287         //!! helper class 'AutoOGuardArray' in order to have
 288         //!! the acquired locks properly released.
 289         AutoOGuardArray aOGuardArray( nCount );
 290
 291         for ( sal_Int32 i = 0; i < nCount; ++i, ++pString, ++pAny )
 292         {
 293             aIter = mpInfo->maMap.find ( *pString );
 294             if ( aIter == aEnd )
 295                 throw UnknownPropertyException( *pString, static_cast< XPropertySet* >( this ) );
 296
 297             if ( (*aIter).second->mnMapId == 0 ) // 0 means it's one of ours !
 298                 _getSingleValue( *((*aIter).second->mpInfo), *pAny );
 299             else
 300             {
 301                 SlaveData * pSlave = maSlaveMap [ (*aIter).second->mnMapId ];
 302                 if (!pSlave->IsInit())
 303                 {
 304                     // acquire mutex in c-tor and releases it in the d-tor (exception safe!).
 305                     if (pSlave->mpSlave->mpMutex)
 306                         aOGuardArray[i].reset( new osl::Guard< comphelper::SolarMutex >(pSlave->mpSlave->mpMutex) );
 307
 308                     pSlave->mpSlave->_preGetValues();
 309                     pSlave->SetInit ( true );
 310                 }
 311                 pSlave->mpSlave->_getSingleValue( *((*aIter).second->mpInfo), *pAny );
 312             }
 313         }
 314
 315         _postSetValues();
 316         SlaveMap::const_iterator aSlaveIter = maSlaveMap.begin(), aSlaveEnd = maSlaveMap.end();
 317         while (aSlaveIter != aSlaveEnd)
 318         {
 319             if ( (*aSlaveIter).second->IsInit())
 320             {
 321                 (*aSlaveIter).second->mpSlave->_postSetValues();
 322                 (*aSlaveIter).second->SetInit ( false );
 323             }
 324             ++aSlaveIter;
 325         }
 326     }
 327     return aValues;
 328 }
 329
 330 void SAL_CALL MasterPropertySet::addPropertiesChangeListener( const Sequence< OUString >&, const Reference< XPropertiesChangeListener >& )
 331     throw(RuntimeException, std::exception)
 332 {
 333     // todo
 334 }
 335
 336 void SAL_CALL MasterPropertySet::removePropertiesChangeListener( const Reference< XPropertiesChangeListener >& )
 337     throw(RuntimeException, std::exception)
 338 {
 339     // todo
 340 }
 341
 342 void SAL_CALL MasterPropertySet::firePropertiesChangeEvent( const Sequence< OUString >&, const Reference< XPropertiesChangeListener >& )
 343     throw(RuntimeException, std::exception)
 344 {
 345     // todo
 346 }
 347
 348 // XPropertyState
 349 PropertyState SAL_CALL MasterPropertySet::getPropertyState( const OUString& PropertyName )
 350     throw(UnknownPropertyException, RuntimeException, std::exception)
 351 {
 352     PropertyDataHash::const_iterator aIter =  mpInfo->maMap.find( PropertyName );
 353     if( aIter == mpInfo->maMap.end())
 354         throw UnknownPropertyException( PropertyName, static_cast< XPropertySet* >( this ) );
 355
 356     PropertyState aState;
 357
 358     if ( (*aIter).second->mnMapId == 0 ) // 0 means it's one of ours !
 359     {
 360         _preGetPropertyState();
 361         _getPropertyState( *((*aIter).second->mpInfo), aState );
 362         _postGetPropertyState();
 363     }
 364     else
 365     {
 366         ChainablePropertySet * pSlave = maSlaveMap [ (*aIter).second->mnMapId ]->mpSlave;
 367
 368         // acquire mutex in c-tor and releases it in the d-tor (exception safe!).
 369         boost::scoped_ptr< osl::Guard< comphelper::SolarMutex > > pMutexGuard;
 370         if (pSlave->mpMutex)
 371             pMutexGuard.reset( new osl::Guard< comphelper::SolarMutex >(pSlave->mpMutex) );
 372
 373         pSlave->_preGetPropertyState();
 374         pSlave->_getPropertyState( *((*aIter).second->mpInfo), aState );
 375         pSlave->_postGetPropertyState();
 376     }
 377
 378     return aState;
 379 }
 380
 381 Sequence< PropertyState > SAL_CALL MasterPropertySet::getPropertyStates( const Sequence< OUString >& rPropertyNames )
 382     throw(UnknownPropertyException, RuntimeException, std::exception)
 383 {
 384     const sal_Int32 nCount = rPropertyNames.getLength();
 385
 386     Sequence< PropertyState > aStates( nCount );
 387     if( nCount )
 388     {
 389         PropertyState * pState = aStates.getArray();
 390         const OUString * pString = rPropertyNames.getConstArray();
 391         PropertyDataHash::const_iterator aEnd = mpInfo->maMap.end(), aIter;
 392         _preGetPropertyState();
 393
 394         for ( sal_Int32 i = 0; i < nCount; ++i, ++pString, ++pState )
 395         {
 396             aIter = mpInfo->maMap.find ( *pString );
 397             if ( aIter == aEnd )
 398                 throw UnknownPropertyException( *pString, static_cast< XPropertySet* >( this ) );
 399
 400             if ( (*aIter).second->mnMapId == 0 ) // 0 means it's one of ours !
 401                 _getPropertyState( *((*aIter).second->mpInfo), *pState );
 402             else
 403             {
 404                 SlaveData * pSlave = maSlaveMap [ (*aIter).second->mnMapId ];
 405                 if (!pSlave->IsInit())
 406                 {
 407                     pSlave->mpSlave->_preGetPropertyState();
 408                     pSlave->SetInit ( true );
 409                 }
 410                 pSlave->mpSlave->_getPropertyState( *((*aIter).second->mpInfo), *pState );
 411             }
 412         }
 413         _postGetPropertyState();
 414         SlaveMap::const_iterator aSlaveIter = maSlaveMap.begin(), aSlaveEnd = maSlaveMap.end();
 415         while (aSlaveIter != aSlaveEnd)
 416         {
 417             if ( (*aSlaveIter).second->IsInit())
 418             {
 419                 (*aSlaveIter).second->mpSlave->_postGetPropertyState();
 420                 (*aSlaveIter).second->SetInit ( false );
 421             }
 422             ++aSlaveIter;
 423         }
 424     }
 425     return aStates;
 426 }
 427
 428 void SAL_CALL MasterPropertySet::setPropertyToDefault( const OUString& rPropertyName )
 429     throw(UnknownPropertyException, RuntimeException, std::exception)
 430 {
 431     PropertyDataHash::const_iterator aIter = mpInfo->maMap.find ( rPropertyName );
 432
 433     if( aIter == mpInfo->maMap.end())
 434         throw UnknownPropertyException( rPropertyName, static_cast< XPropertySet* >( this ) );
 435     _setPropertyToDefault( *((*aIter).second->mpInfo) );
 436 }
 437
 438 Any SAL_CALL MasterPropertySet::getPropertyDefault( const OUString& rPropertyName )
 439     throw(UnknownPropertyException, WrappedTargetException, RuntimeException, std::exception)
 440 {
 441     PropertyDataHash::const_iterator aIter = mpInfo->maMap.find ( rPropertyName );
 442
 443     if( aIter == mpInfo->maMap.end())
 444         throw UnknownPropertyException( rPropertyName, static_cast< XPropertySet* >( this ) );
 445     return _getPropertyDefault( *((*aIter).second->mpInfo) );
 446 }
 447
 448 void MasterPropertySet::_preGetPropertyState ()
 449     throw(::com::sun::star::beans::UnknownPropertyException, ::com::sun::star::beans::PropertyVetoException, ::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::lang::WrappedTargetException )
 450 {
 451     OSL_FAIL( "you have to implement this yourself!");
 452 }
 453
 454 void MasterPropertySet::_getPropertyState( const comphelper::PropertyInfo&, PropertyState& )
 455     throw(UnknownPropertyException )
 456 {
 457     OSL_FAIL( "you have to implement this yourself!");
 458 }
 459
 460 void MasterPropertySet::_postGetPropertyState ()
 461     throw(::com::sun::star::beans::UnknownPropertyException, ::com::sun::star::beans::PropertyVetoException, ::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::lang::WrappedTargetException )
 462 {
 463     OSL_FAIL( "you have to implement this yourself!");
 464 }
 465
 466 void MasterPropertySet::_setPropertyToDefault( const comphelper::PropertyInfo& )
 467     throw(UnknownPropertyException )
 468 {
 469     OSL_FAIL( "you have to implement this yourself!");
 470 }
 471
 472 Any MasterPropertySet::_getPropertyDefault( const comphelper::PropertyInfo& )
 473     throw(UnknownPropertyException, WrappedTargetException )
 474 {
 475     OSL_FAIL( "you have to implement this yourself!");
 476     Any aAny;
 477     return aAny;
 478 }
 479
 480 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */