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
  28 #include <memory>
  29 #include <vector>
  30
  31 class AutoOGuardArray
  32 {
  33     std::vector<std::unique_ptr< osl::Guard< comphelper::SolarMutex > >>  maGuardArray;
  34
  35 public:
  36     explicit AutoOGuardArray( sal_Int32 nNumElements );
  37
  38     std::unique_ptr< osl::Guard< comphelper::SolarMutex > > &  operator[] ( sal_Int32 i ) { return maGuardArray[i]; }
  39 };
  40
  41 AutoOGuardArray::AutoOGuardArray( sal_Int32 nNumElements ) : maGuardArray(nNumElements)
  42 {
  43 }
  44
  45
  46 using namespace ::comphelper;
  47 using namespace ::com::sun::star;
  48 using namespace ::com::sun::star::uno;
  49 using namespace ::com::sun::star::lang;
  50 using namespace ::com::sun::star::beans;
  51
  52
  53 SlaveData::SlaveData ( ChainablePropertySet *pSlave)
  54 : mxSlave ( pSlave )
  55 , mbInit ( false )
  56 {
  57 }
  58
  59 MasterPropertySet::MasterPropertySet( comphelper::MasterPropertySetInfo* pInfo, comphelper::SolarMutex* pMutex )
  60     throw()
  61 : mpMutex ( pMutex )
  62 , mnLastId ( 0 )
  63 , mxInfo ( pInfo )
  64 {
  65 }
  66
  67 MasterPropertySet::~MasterPropertySet()
  68     throw()
  69 {
  70     for( auto& rSlave : maSlaveMap )
  71         delete rSlave.second;
  72 }
  73
  74 // XPropertySet
  75 Reference< XPropertySetInfo > SAL_CALL MasterPropertySet::getPropertySetInfo(  )
  76 {
  77     return mxInfo.get();
  78 }
  79
  80 void MasterPropertySet::registerSlave ( ChainablePropertySet *pNewSet )
  81     throw()
  82 {
  83     maSlaveMap [ ++mnLastId ] = new SlaveData ( pNewSet );
  84     mxInfo->add ( pNewSet->mxInfo->maMap, mnLastId );
  85 }
  86
  87 void SAL_CALL MasterPropertySet::setPropertyValue( const OUString& rPropertyName, const Any& rValue )
  88 {
  89     // acquire mutex in c-tor and releases it in the d-tor (exception safe!).
  90     std::unique_ptr< osl::Guard< comphelper::SolarMutex > > xMutexGuard;
  91     if (mpMutex)
  92         xMutexGuard.reset( new osl::Guard< comphelper::SolarMutex >(mpMutex) );
  93
  94     PropertyDataHash::const_iterator aIter = mxInfo->maMap.find ( rPropertyName );
  95
  96     if( aIter == mxInfo->maMap.end())
  97         throw UnknownPropertyException( rPropertyName, static_cast< XPropertySet* >( this ) );
  98
  99     if ( (*aIter).second->mnMapId == 0 ) // 0 means it's one of ours !
 100     {
 101         _preSetValues();
 102         _setSingleValue( *((*aIter).second->mpInfo), rValue );
 103         _postSetValues();
 104     }
 105     else
 106     {
 107         ChainablePropertySet * pSlave = maSlaveMap [ (*aIter).second->mnMapId ]->mxSlave.get();
 108
 109         // acquire mutex in c-tor and releases it in the d-tor (exception safe!).
 110         std::unique_ptr< osl::Guard< comphelper::SolarMutex > > xMutexGuard2;
 111         if (pSlave->mpMutex)
 112             xMutexGuard2.reset( new osl::Guard< comphelper::SolarMutex >(pSlave->mpMutex) );
 113
 114         pSlave->_preSetValues();
 115         pSlave->_setSingleValue( *((*aIter).second->mpInfo), rValue );
 116         pSlave->_postSetValues();
 117     }
 118 }
 119
 120 Any SAL_CALL MasterPropertySet::getPropertyValue( const OUString& rPropertyName )
 121 {
 122     // acquire mutex in c-tor and releases it in the d-tor (exception safe!).
 123     std::unique_ptr< osl::Guard< comphelper::SolarMutex > > xMutexGuard;
 124     if (mpMutex)
 125         xMutexGuard.reset( new osl::Guard< comphelper::SolarMutex >(mpMutex) );
 126
 127     PropertyDataHash::const_iterator aIter = mxInfo->maMap.find ( rPropertyName );
 128
 129     if( aIter == mxInfo->maMap.end())
 130         throw UnknownPropertyException( rPropertyName, static_cast< XPropertySet* >( this ) );
 131
 132     Any aAny;
 133     if ( (*aIter).second->mnMapId == 0 ) // 0 means it's one of ours !
 134     {
 135         _preGetValues();
 136         _getSingleValue( *((*aIter).second->mpInfo), aAny );
 137         _postGetValues();
 138     }
 139     else
 140     {
 141         ChainablePropertySet * pSlave = maSlaveMap [ (*aIter).second->mnMapId ]->mxSlave.get();
 142
 143         // acquire mutex in c-tor and releases it in the d-tor (exception safe!).
 144         std::unique_ptr< osl::Guard< comphelper::SolarMutex > > xMutexGuard2;
 145         if (pSlave->mpMutex)
 146             xMutexGuard2.reset( new osl::Guard< comphelper::SolarMutex >(pSlave->mpMutex) );
 147
 148         pSlave->_preGetValues();
 149         pSlave->_getSingleValue( *((*aIter).second->mpInfo), aAny );
 150         pSlave->_postGetValues();
 151     }
 152     return aAny;
 153 }
 154
 155 void SAL_CALL MasterPropertySet::addPropertyChangeListener( const OUString&, const Reference< XPropertyChangeListener >& )
 156 {
 157     // todo
 158 }
 159
 160 void SAL_CALL MasterPropertySet::removePropertyChangeListener( const OUString&, const Reference< XPropertyChangeListener >& )
 161 {
 162     // todo
 163 }
 164
 165 void SAL_CALL MasterPropertySet::addVetoableChangeListener( const OUString&, const Reference< XVetoableChangeListener >& )
 166 {
 167     // todo
 168 }
 169
 170 void SAL_CALL MasterPropertySet::removeVetoableChangeListener( const OUString&, const Reference< XVetoableChangeListener >& )
 171 {
 172     // todo
 173 }
 174
 175 // XMultiPropertySet
 176 void SAL_CALL MasterPropertySet::setPropertyValues( const Sequence< OUString >& aPropertyNames, const Sequence< Any >& aValues )
 177 {
 178     // acquire mutex in c-tor and releases it in the d-tor (exception safe!).
 179     std::unique_ptr< osl::Guard< comphelper::SolarMutex > > xMutexGuard;
 180     if (mpMutex)
 181         xMutexGuard.reset( new osl::Guard< comphelper::SolarMutex >(mpMutex) );
 182
 183     const sal_Int32 nCount = aPropertyNames.getLength();
 184
 185     if( nCount != aValues.getLength() )
 186         throw IllegalArgumentException();
 187
 188     if( nCount )
 189     {
 190         _preSetValues();
 191
 192         const Any * pAny = aValues.getConstArray();
 193         const OUString * pString = aPropertyNames.getConstArray();
 194         PropertyDataHash::const_iterator aEnd = mxInfo->maMap.end(), aIter;
 195
 196         //!! have a unique_ptr to an array of OGuards in order to have the
 197         //!! allocated memory properly freed (exception safe!).
 198         //!! Since the array itself has unique_ptrs as members we have to use a
 199         //!! helper class 'AutoOGuardArray' in order to have
 200         //!! the acquired locks properly released.
 201         AutoOGuardArray aOGuardArray( nCount );
 202
 203         for ( sal_Int32 i = 0; i < nCount; ++i, ++pString, ++pAny )
 204         {
 205             aIter = mxInfo->maMap.find ( *pString );
 206             if ( aIter == aEnd )
 207                 throw RuntimeException( *pString, static_cast< XPropertySet* >( this ) );
 208
 209             if ( (*aIter).second->mnMapId == 0 ) // 0 means it's one of ours !
 210                 _setSingleValue( *((*aIter).second->mpInfo), *pAny );
 211             else
 212             {
 213                 SlaveData * pSlave = maSlaveMap [ (*aIter).second->mnMapId ];
 214                 if (!pSlave->IsInit())
 215                 {
 216                     // acquire mutex in c-tor and releases it in the d-tor (exception safe!).
 217                     if (pSlave->mxSlave->mpMutex)
 218                         aOGuardArray[i].reset( new osl::Guard< comphelper::SolarMutex >(pSlave->mxSlave->mpMutex) );
 219
 220                     pSlave->mxSlave->_preSetValues();
 221                     pSlave->SetInit ( true );
 222                 }
 223                 pSlave->mxSlave->_setSingleValue( *((*aIter).second->mpInfo), *pAny );
 224             }
 225         }
 226
 227         _postSetValues();
 228         for( const auto& rSlave : maSlaveMap )
 229         {
 230             if( rSlave.second->IsInit() )
 231             {
 232                 rSlave.second->mxSlave->_postSetValues();
 233                 rSlave.second->SetInit( false );
 234             }
 235         }
 236     }
 237 }
 238
 239 Sequence< Any > SAL_CALL MasterPropertySet::getPropertyValues( const Sequence< OUString >& aPropertyNames )
 240 {
 241     // acquire mutex in c-tor and releases it in the d-tor (exception safe!).
 242     std::unique_ptr< osl::Guard< comphelper::SolarMutex > > xMutexGuard;
 243     if (mpMutex)
 244         xMutexGuard.reset( new osl::Guard< comphelper::SolarMutex >(mpMutex) );
 245
 246     const sal_Int32 nCount = aPropertyNames.getLength();
 247
 248     Sequence < Any > aValues ( nCount );
 249
 250     if( nCount )
 251     {
 252         _preGetValues();
 253
 254         Any * pAny = aValues.getArray();
 255         const OUString * pString = aPropertyNames.getConstArray();
 256         PropertyDataHash::const_iterator aEnd = mxInfo->maMap.end(), aIter;
 257
 258         //!! have a unique_ptr to an array of OGuards in order to have the
 259         //!! allocated memory properly freed (exception safe!).
 260         //!! Since the array itself has unique_ptrs as members we have to use a
 261         //!! helper class 'AutoOGuardArray' in order to have
 262         //!! the acquired locks properly released.
 263         AutoOGuardArray aOGuardArray( nCount );
 264
 265         for ( sal_Int32 i = 0; i < nCount; ++i, ++pString, ++pAny )
 266         {
 267             aIter = mxInfo->maMap.find ( *pString );
 268             if ( aIter == aEnd )
 269                 throw RuntimeException( *pString, static_cast< XPropertySet* >( this ) );
 270
 271             if ( (*aIter).second->mnMapId == 0 ) // 0 means it's one of ours !
 272                 _getSingleValue( *((*aIter).second->mpInfo), *pAny );
 273             else
 274             {
 275                 SlaveData * pSlave = maSlaveMap [ (*aIter).second->mnMapId ];
 276                 if (!pSlave->IsInit())
 277                 {
 278                     // acquire mutex in c-tor and releases it in the d-tor (exception safe!).
 279                     if (pSlave->mxSlave->mpMutex)
 280                         aOGuardArray[i].reset( new osl::Guard< comphelper::SolarMutex >(pSlave->mxSlave->mpMutex) );
 281
 282                     pSlave->mxSlave->_preGetValues();
 283                     pSlave->SetInit ( true );
 284                 }
 285                 pSlave->mxSlave->_getSingleValue( *((*aIter).second->mpInfo), *pAny );
 286             }
 287         }
 288
 289         _postSetValues();
 290         for( const auto& rSlave : maSlaveMap )
 291         {
 292             if( rSlave.second->IsInit() )
 293             {
 294                 rSlave.second->mxSlave->_postSetValues();
 295                 rSlave.second->SetInit( false );
 296             }
 297         }
 298     }
 299     return aValues;
 300 }
 301
 302 void SAL_CALL MasterPropertySet::addPropertiesChangeListener( const Sequence< OUString >&, const Reference< XPropertiesChangeListener >& )
 303 {
 304     // todo
 305 }
 306
 307 void SAL_CALL MasterPropertySet::removePropertiesChangeListener( const Reference< XPropertiesChangeListener >& )
 308 {
 309     // todo
 310 }
 311
 312 void SAL_CALL MasterPropertySet::firePropertiesChangeEvent( const Sequence< OUString >&, const Reference< XPropertiesChangeListener >& )
 313 {
 314     // todo
 315 }
 316
 317 // XPropertyState
 318 PropertyState SAL_CALL MasterPropertySet::getPropertyState( const OUString& PropertyName )
 319 {
 320     PropertyDataHash::const_iterator aIter =  mxInfo->maMap.find( PropertyName );
 321     if( aIter == mxInfo->maMap.end())
 322         throw UnknownPropertyException( PropertyName, static_cast< XPropertySet* >( this ) );
 323
 324     // 0 means it's one of ours !
 325     if ( (*aIter).second->mnMapId != 0 )
 326     {
 327         ChainablePropertySet * pSlave = maSlaveMap [ (*aIter).second->mnMapId ]->mxSlave.get();
 328
 329         // acquire mutex in c-tor and releases it in the d-tor (exception safe!).
 330         std::unique_ptr< osl::Guard< comphelper::SolarMutex > > xMutexGuard;
 331         if (pSlave->mpMutex)
 332             xMutexGuard.reset( new osl::Guard< comphelper::SolarMutex >(pSlave->mpMutex) );
 333     }
 334
 335     return PropertyState_AMBIGUOUS_VALUE;
 336 }
 337
 338 Sequence< PropertyState > SAL_CALL MasterPropertySet::getPropertyStates( const Sequence< OUString >& rPropertyNames )
 339 {
 340     const sal_Int32 nCount = rPropertyNames.getLength();
 341
 342     Sequence< PropertyState > aStates( nCount );
 343     if( nCount )
 344     {
 345         PropertyState * pState = aStates.getArray();
 346         const OUString * pString = rPropertyNames.getConstArray();
 347         PropertyDataHash::const_iterator aEnd = mxInfo->maMap.end(), aIter;
 348
 349         for ( sal_Int32 i = 0; i < nCount; ++i, ++pString, ++pState )
 350         {
 351             aIter = mxInfo->maMap.find ( *pString );
 352             if ( aIter == aEnd )
 353                 throw UnknownPropertyException( *pString, static_cast< XPropertySet* >( this ) );
 354
 355             // 0 means it's one of ours !
 356             if ( (*aIter).second->mnMapId != 0 )
 357             {
 358                 SlaveData * pSlave = maSlaveMap [ (*aIter).second->mnMapId ];
 359                 if (!pSlave->IsInit())
 360                 {
 361                     pSlave->SetInit ( true );
 362                 }
 363             }
 364         }
 365         for( const auto& rSlave : maSlaveMap )
 366         {
 367             if( rSlave.second->IsInit() )
 368             {
 369                 rSlave.second->SetInit( false );
 370             }
 371         }
 372     }
 373     return aStates;
 374 }
 375
 376 void SAL_CALL MasterPropertySet::setPropertyToDefault( const OUString& rPropertyName )
 377 {
 378     PropertyDataHash::const_iterator aIter = mxInfo->maMap.find ( rPropertyName );
 379
 380     if( aIter == mxInfo->maMap.end())
 381         throw UnknownPropertyException( rPropertyName, static_cast< XPropertySet* >( this ) );
 382 }
 383
 384 Any SAL_CALL MasterPropertySet::getPropertyDefault( const OUString& rPropertyName )
 385 {
 386     PropertyDataHash::const_iterator aIter = mxInfo->maMap.find ( rPropertyName );
 387
 388     if( aIter == mxInfo->maMap.end())
 389         throw UnknownPropertyException( rPropertyName, static_cast< XPropertySet* >( this ) );
 390     return Any();
 391 }
 392
 393 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */