cppuhelper/source/interfacecontainer.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 <cppuhelper/interfacecontainer.hxx>
  22 #include <cppuhelper/propshlp.hxx>
  23
  24 #include <osl/diagnose.h>
  25 #include <osl/mutex.hxx>
  26
  27 #include <memory>
  28
  29 #include <com/sun/star/lang/XEventListener.hpp>
  30
  31
  32 using namespace osl;
  33 using namespace com::sun::star::uno;
  34 using namespace com::sun::star::lang;
  35
  36 namespace cppu
  37 {
  38 /**
  39  * Remove an element from an interface sequence.
  40  */
  41 static void sequenceRemoveElementAt( Sequence< Reference< XInterface > > & rSeq, sal_Int32 index )
  42 {
  43     sal_Int32 nNewLen = rSeq.getLength() - 1;
  44
  45     Sequence< Reference< XInterface > > aDestSeq( rSeq.getLength() - 1 );
  46     // getArray on a const sequence is faster
  47     const Reference< XInterface > * pSource = rSeq.getConstArray();
  48     Reference< XInterface > * pDest = aDestSeq.getArray();
  49     sal_Int32 i = 0;
  50     for( ; i < index; i++ )
  51         pDest[i] = pSource[i];
  52     for( sal_Int32 j = i ; j < nNewLen; j++ )
  53         pDest[j] = pSource[j+1];
  54     rSeq = aDestSeq;
  55 }
  56
  57 OInterfaceIteratorHelper::OInterfaceIteratorHelper( OInterfaceContainerHelper & rCont_ )
  58     : rCont( rCont_ )
  59 {
  60     MutexGuard aGuard( rCont.rMutex );
  61     if( rCont.bInUse )
  62         // worst case, two iterators at the same time
  63         rCont.copyAndResetInUse();
  64     bIsList = rCont_.bIsList;
  65     aData = rCont_.aData;
  66     if( bIsList )
  67     {
  68         rCont.bInUse = true;
  69         nRemain = aData.pAsSequence->getLength();
  70     }
  71     else if( aData.pAsInterface )
  72     {
  73         aData.pAsInterface->acquire();
  74         nRemain = 1;
  75     }
  76     else
  77         nRemain = 0;
  78 }
  79
  80 OInterfaceIteratorHelper::~OInterfaceIteratorHelper()
  81 {
  82     bool bShared;
  83     {
  84     MutexGuard aGuard( rCont.rMutex );
  85     // bResetInUse protect the iterator against recursion
  86     bShared = aData.pAsSequence == rCont.aData.pAsSequence && rCont.bIsList;
  87     if( bShared )
  88     {
  89         OSL_ENSURE( rCont.bInUse, "OInterfaceContainerHelper must be in use" );
  90         rCont.bInUse = false;
  91     }
  92     }
  93
  94     if( !bShared )
  95     {
  96         if( bIsList )
  97             // Sequence owned by the iterator
  98             delete aData.pAsSequence;
  99         else if( aData.pAsInterface )
 100             // Interface is acquired by the iterator
 101             aData.pAsInterface->release();
 102     }
 103 }
 104
 105 XInterface * OInterfaceIteratorHelper::next()
 106 {
 107     if( nRemain )
 108     {
 109         nRemain--;
 110         if( bIsList )
 111             // typecase to const,so the getArray method is faster
 112             return aData.pAsSequence->getConstArray()[nRemain].get();
 113         if( aData.pAsInterface )
 114             return aData.pAsInterface;
 115     }
 116     // exception
 117     return nullptr;
 118 }
 119
 120 void OInterfaceIteratorHelper::remove()
 121 {
 122     if( bIsList )
 123     {
 124         OSL_ASSERT( nRemain >= 0 &&
 125                     nRemain < aData.pAsSequence->getLength() );
 126         XInterface * p = aData.pAsSequence->getConstArray()[nRemain].get();
 127         rCont.removeInterface( * reinterpret_cast< const Reference< XInterface > * >( &p ) );
 128     }
 129     else
 130     {
 131         OSL_ASSERT( 0 == nRemain );
 132         rCont.removeInterface( * reinterpret_cast< const Reference< XInterface > * >(&aData.pAsInterface));
 133     }
 134 }
 135
 136 OInterfaceContainerHelper::OInterfaceContainerHelper( Mutex & rMutex_ )
 137     : rMutex( rMutex_ )
 138     , bInUse( false )
 139     , bIsList( false )
 140 {
 141 }
 142
 143 OInterfaceContainerHelper::~OInterfaceContainerHelper()
 144 {
 145     OSL_ENSURE( !bInUse, "~OInterfaceContainerHelper but is in use" );
 146     if( bIsList )
 147         delete aData.pAsSequence;
 148     else if( aData.pAsInterface )
 149         aData.pAsInterface->release();
 150 }
 151
 152 sal_Int32 OInterfaceContainerHelper::getLength() const
 153 {
 154     MutexGuard aGuard( rMutex );
 155     if( bIsList )
 156         return aData.pAsSequence->getLength();
 157     if( aData.pAsInterface )
 158         return 1;
 159     return 0;
 160 }
 161
 162 Sequence< Reference<XInterface> > OInterfaceContainerHelper::getElements() const
 163 {
 164     MutexGuard aGuard( rMutex );
 165     if( bIsList )
 166         return *aData.pAsSequence;
 167     if( aData.pAsInterface )
 168     {
 169         Reference<XInterface> x( aData.pAsInterface );
 170         return Sequence< Reference< XInterface > >( &x, 1 );
 171     }
 172     return Sequence< Reference< XInterface > >();
 173 }
 174
 175 void OInterfaceContainerHelper::copyAndResetInUse()
 176 {
 177     OSL_ENSURE( bInUse, "OInterfaceContainerHelper not in use" );
 178     if( bInUse )
 179     {
 180         // this should be the worst case. If an iterator is active
 181         // and a new Listener is added.
 182         if( bIsList )
 183             aData.pAsSequence = new Sequence< Reference< XInterface > >( *aData.pAsSequence );
 184         else if( aData.pAsInterface )
 185             aData.pAsInterface->acquire();
 186
 187         bInUse = false;
 188     }
 189 }
 190
 191 sal_Int32 OInterfaceContainerHelper::addInterface( const Reference<XInterface> & rListener )
 192 {
 193     OSL_ASSERT( rListener.is() );
 194     MutexGuard aGuard( rMutex );
 195     if( bInUse )
 196         copyAndResetInUse();
 197
 198     if( bIsList )
 199     {
 200         sal_Int32 nLen = aData.pAsSequence->getLength();
 201         aData.pAsSequence->realloc( nLen +1 );
 202         aData.pAsSequence->getArray()[ nLen ] = rListener;
 203         return nLen +1;
 204     }
 205     if( aData.pAsInterface )
 206     {
 207         Sequence< Reference< XInterface > > * pSeq = new Sequence< Reference< XInterface > >( 2 );
 208         Reference<XInterface> * pArray = pSeq->getArray();
 209         pArray[0] = aData.pAsInterface;
 210         pArray[1] = rListener;
 211         aData.pAsInterface->release();
 212         aData.pAsSequence = pSeq;
 213         bIsList = true;
 214         return 2;
 215     }
 216     aData.pAsInterface = rListener.get();
 217     if( rListener.is() )
 218         rListener->acquire();
 219     return 1;
 220 }
 221
 222 sal_Int32 OInterfaceContainerHelper::removeInterface( const Reference<XInterface> & rListener )
 223 {
 224     OSL_ASSERT( rListener.is() );
 225     MutexGuard aGuard( rMutex );
 226     if( bInUse )
 227         copyAndResetInUse();
 228
 229     if( bIsList )
 230     {
 231         const Reference<XInterface> * pL = aData.pAsSequence->getConstArray();
 232         sal_Int32 nLen = aData.pAsSequence->getLength();
 233         sal_Int32 i;
 234         for( i = 0; i < nLen; i++ )
 235         {
 236             // It is not valid to compare the pointer directly, but it's faster.
 237             if( pL[i].get() == rListener.get() )
 238             {
 239                 sequenceRemoveElementAt( *aData.pAsSequence, i );
 240                 break;
 241             }
 242         }
 243
 244         if( i == nLen )
 245         {
 246             // interface not found, use the correct compare method
 247             for( i = 0; i < nLen; i++ )
 248             {
 249                 if( pL[i] == rListener )
 250                 {
 251                     sequenceRemoveElementAt(*aData.pAsSequence, i );
 252                     break;
 253                 }
 254             }
 255         }
 256
 257         if( aData.pAsSequence->getLength() == 1 )
 258         {
 259             XInterface * p = aData.pAsSequence->getConstArray()[0].get();
 260             p->acquire();
 261             delete aData.pAsSequence;
 262             aData.pAsInterface = p;
 263             bIsList = false;
 264             return 1;
 265         }
 266         return aData.pAsSequence->getLength();
 267     }
 268     if( aData.pAsInterface && Reference<XInterface>( aData.pAsInterface ) == rListener )
 269     {
 270         aData.pAsInterface->release();
 271         aData.pAsInterface = nullptr;
 272     }
 273     return aData.pAsInterface ? 1 : 0;
 274 }
 275
 276 void OInterfaceContainerHelper::disposeAndClear( const EventObject & rEvt )
 277 {
 278     ClearableMutexGuard aGuard( rMutex );
 279     OInterfaceIteratorHelper aIt( *this );
 280     // Release container, in case new entries come while disposing
 281     OSL_ENSURE( !bIsList || bInUse, "OInterfaceContainerHelper not in use" );
 282     if( !bIsList && aData.pAsInterface )
 283         aData.pAsInterface->release();
 284     // set the member to null, use the iterator to delete the values
 285     aData.pAsInterface = nullptr;
 286     bIsList = false;
 287     bInUse = false;
 288     aGuard.clear();
 289     while( aIt.hasMoreElements() )
 290     {
 291         try
 292         {
 293             Reference<XEventListener > xLst( aIt.next(), UNO_QUERY );
 294             if( xLst.is() )
 295                 xLst->disposing( rEvt );
 296         }
 297         catch ( RuntimeException & )
 298         {
 299             // be robust, if e.g. a remote bridge has disposed already.
 300             // there is no way to delegate the error to the caller :o(.
 301         }
 302     }
 303 }
 304
 305
 306 void OInterfaceContainerHelper::clear()
 307 {
 308     ClearableMutexGuard aGuard( rMutex );
 309     OInterfaceIteratorHelper aIt( *this );
 310     // Release container, in case new entries come while disposing
 311     OSL_ENSURE( !bIsList || bInUse, "OInterfaceContainerHelper not in use" );
 312     if( !bIsList && aData.pAsInterface )
 313         aData.pAsInterface->release();
 314     // set the member to null, use the iterator to delete the values
 315     aData.pAsInterface = nullptr;
 316     bIsList = false;
 317     bInUse = false;
 318     // release mutex before aIt destructor call
 319     aGuard.clear();
 320 }
 321
 322 // specialized class for type
 323
 324 typedef std::vector< std::pair < Type , void* > > t_type2ptr;
 325
 326 OMultiTypeInterfaceContainerHelper::OMultiTypeInterfaceContainerHelper( Mutex & rMutex_ )
 327     : rMutex( rMutex_ )
 328 {
 329     m_pMap = new t_type2ptr;
 330 }
 331
 332 OMultiTypeInterfaceContainerHelper::~OMultiTypeInterfaceContainerHelper()
 333 {
 334     t_type2ptr * pMap = static_cast<t_type2ptr *>(m_pMap);
 335
 336     for (auto& rItem : *pMap)
 337     {
 338         delete static_cast<OInterfaceContainerHelper*>(rItem.second);
 339         rItem.second = nullptr;
 340     }
 341     delete pMap;
 342 }
 343
 344 Sequence< Type > OMultiTypeInterfaceContainerHelper::getContainedTypes() const
 345 {
 346     t_type2ptr * pMap = static_cast<t_type2ptr *>(m_pMap);
 347     t_type2ptr::size_type nSize;
 348
 349     ::osl::MutexGuard aGuard( rMutex );
 350     nSize = pMap->size();
 351     if( nSize )
 352     {
 353         css::uno::Sequence< Type > aInterfaceTypes( nSize );
 354         Type * pArray = aInterfaceTypes.getArray();
 355
 356         sal_Int32 i = 0;
 357         for (const auto& rItem : *pMap)
 358         {
 359             // are interfaces added to this container?
 360             if( static_cast<OInterfaceContainerHelper*>(rItem.second)->getLength() )
 361                 // yes, put the type in the array
 362                 pArray[i++] = rItem.first;
 363         }
 364         if( static_cast<t_type2ptr::size_type>(i) != nSize ) {
 365             // may be empty container, reduce the sequence to the right size
 366             aInterfaceTypes = css::uno::Sequence< Type >( pArray, i );
 367         }
 368         return aInterfaceTypes;
 369     }
 370     return css::uno::Sequence< Type >();
 371 }
 372
 373 static t_type2ptr::iterator findType(t_type2ptr *pMap, const Type & rKey )
 374 {
 375     return std::find_if(pMap->begin(), pMap->end(),
 376         [&rKey](const t_type2ptr::value_type& rItem) { return rItem.first == rKey; });
 377 }
 378
 379 OInterfaceContainerHelper * OMultiTypeInterfaceContainerHelper::getContainer( const Type & rKey ) const
 380 {
 381     ::osl::MutexGuard aGuard( rMutex );
 382
 383     t_type2ptr * pMap = static_cast<t_type2ptr *>(m_pMap);
 384     t_type2ptr::iterator iter = findType( pMap, rKey );
 385     if( iter != pMap->end() )
 386             return static_cast<OInterfaceContainerHelper*>((*iter).second);
 387     return nullptr;
 388 }
 389
 390 sal_Int32 OMultiTypeInterfaceContainerHelper::addInterface(
 391     const Type & rKey, const Reference< XInterface > & rListener )
 392 {
 393     ::osl::MutexGuard aGuard( rMutex );
 394     t_type2ptr * pMap = static_cast<t_type2ptr *>(m_pMap);
 395     t_type2ptr::iterator iter = findType( pMap, rKey );
 396     if( iter == pMap->end() )
 397     {
 398         OInterfaceContainerHelper * pLC = new OInterfaceContainerHelper( rMutex );
 399         pMap->push_back(std::pair<Type, void*>(rKey, pLC));
 400         return pLC->addInterface( rListener );
 401     }
 402     return static_cast<OInterfaceContainerHelper*>((*iter).second)->addInterface( rListener );
 403 }
 404
 405 sal_Int32 OMultiTypeInterfaceContainerHelper::removeInterface(
 406     const Type & rKey, const Reference< XInterface > & rListener )
 407 {
 408     ::osl::MutexGuard aGuard( rMutex );
 409
 410     // search container with id nUik
 411     t_type2ptr * pMap = static_cast<t_type2ptr *>(m_pMap);
 412     t_type2ptr::iterator iter = findType( pMap, rKey );
 413         // container found?
 414     if( iter != pMap->end() )
 415         return static_cast<OInterfaceContainerHelper*>((*iter).second)->removeInterface( rListener );
 416
 417     // no container with this id. Always return 0
 418     return 0;
 419 }
 420
 421 void OMultiTypeInterfaceContainerHelper::disposeAndClear( const EventObject & rEvt )
 422 {
 423     t_type2ptr::size_type nSize = 0;
 424     std::unique_ptr<OInterfaceContainerHelper *[]> ppListenerContainers;
 425     {
 426         ::osl::MutexGuard aGuard( rMutex );
 427         t_type2ptr * pMap = static_cast<t_type2ptr *>(m_pMap);
 428         nSize = pMap->size();
 429         if( nSize )
 430         {
 431             typedef OInterfaceContainerHelper* ppp;
 432             ppListenerContainers.reset(new ppp[nSize]);
 433             //ppListenerContainers = new (ListenerContainer*)[nSize];
 434
 435             t_type2ptr::size_type i = 0;
 436             for (const auto& rItem : *pMap)
 437             {
 438                 ppListenerContainers[i++] = static_cast<OInterfaceContainerHelper*>(rItem.second);
 439             }
 440         }
 441     }
 442
 443     // create a copy, because do not fire event in a guarded section
 444     for( t_type2ptr::size_type i = 0;
 445             i < nSize; i++ )
 446     {
 447         if( ppListenerContainers[i] )
 448             ppListenerContainers[i]->disposeAndClear( rEvt );
 449     }
 450 }
 451
 452 void OMultiTypeInterfaceContainerHelper::clear()
 453 {
 454     ::osl::MutexGuard aGuard( rMutex );
 455     t_type2ptr * pMap = static_cast<t_type2ptr *>(m_pMap);
 456
 457     for (auto& rItem : *pMap)
 458     {
 459         static_cast<OInterfaceContainerHelper*>(rItem.second)->clear();
 460     }
 461 }
 462
 463 // specialized class for long
 464
 465 typedef std::vector< std::pair < sal_Int32 , void* > > t_long2ptr;
 466
 467 static t_long2ptr::iterator findLong(t_long2ptr *pMap, sal_Int32 nKey )
 468 {
 469     return std::find_if(pMap->begin(), pMap->end(),
 470         [&nKey](const t_long2ptr::value_type& rItem) { return rItem.first == nKey; });
 471 }
 472
 473 OMultiTypeInterfaceContainerHelperInt32::OMultiTypeInterfaceContainerHelperInt32( Mutex & rMutex_ )
 474     : m_pMap( nullptr )
 475     , rMutex( rMutex_ )
 476 {
 477     // delay pMap allocation until necessary.
 478 }
 479
 480 OMultiTypeInterfaceContainerHelperInt32::~OMultiTypeInterfaceContainerHelperInt32()
 481 {
 482     if (!m_pMap)
 483         return;
 484
 485     t_long2ptr * pMap = static_cast<t_long2ptr *>(m_pMap);
 486
 487     for (auto& rItem : *pMap)
 488     {
 489         delete static_cast<OInterfaceContainerHelper*>(rItem.second);
 490         rItem.second = nullptr;
 491     }
 492     delete pMap;
 493 }
 494
 495 Sequence< sal_Int32 > OMultiTypeInterfaceContainerHelperInt32::getContainedTypes() const
 496 {
 497     t_long2ptr * pMap = static_cast<t_long2ptr *>(m_pMap);
 498     t_long2ptr::size_type nSize;
 499
 500     ::osl::MutexGuard aGuard( rMutex );
 501     nSize = pMap ? pMap->size() : 0;
 502     if( nSize )
 503     {
 504         css::uno::Sequence< sal_Int32 > aInterfaceTypes( nSize );
 505         sal_Int32 * pArray = aInterfaceTypes.getArray();
 506
 507         sal_Int32 i = 0;
 508         for (const auto& rItem : *pMap)
 509         {
 510             // are interfaces added to this container?
 511             if( static_cast<OInterfaceContainerHelper*>(rItem.second)->getLength() )
 512                 // yes, put the type in the array
 513                 pArray[i++] = rItem.first;
 514         }
 515         if( static_cast<t_long2ptr::size_type>(i) != nSize ) {
 516             // may be empty container, reduce the sequence to the right size
 517             aInterfaceTypes = css::uno::Sequence< sal_Int32 >( pArray, i );
 518         }
 519         return aInterfaceTypes;
 520     }
 521     return css::uno::Sequence< sal_Int32 >();
 522 }
 523
 524 OInterfaceContainerHelper * OMultiTypeInterfaceContainerHelperInt32::getContainer( const sal_Int32 & rKey ) const
 525 {
 526     ::osl::MutexGuard aGuard( rMutex );
 527
 528     if (!m_pMap)
 529         return nullptr;
 530     t_long2ptr * pMap = static_cast<t_long2ptr *>(m_pMap);
 531     t_long2ptr::iterator iter = findLong( pMap, rKey );
 532     if( iter != pMap->end() )
 533             return static_cast<OInterfaceContainerHelper*>((*iter).second);
 534     return nullptr;
 535 }
 536
 537 sal_Int32 OMultiTypeInterfaceContainerHelperInt32::addInterface(
 538     const sal_Int32 & rKey, const Reference< XInterface > & rListener )
 539 {
 540     ::osl::MutexGuard aGuard( rMutex );
 541     if (!m_pMap)
 542         m_pMap = new t_long2ptr;
 543     t_long2ptr * pMap = static_cast<t_long2ptr *>(m_pMap);
 544     t_long2ptr::iterator iter = findLong( pMap, rKey );
 545     if( iter == pMap->end() )
 546     {
 547         OInterfaceContainerHelper * pLC = new OInterfaceContainerHelper( rMutex );
 548         pMap->push_back(std::pair< sal_Int32, void* >(rKey, pLC));
 549         return pLC->addInterface( rListener );
 550     }
 551     return static_cast<OInterfaceContainerHelper*>((*iter).second)->addInterface( rListener );
 552 }
 553
 554 sal_Int32 OMultiTypeInterfaceContainerHelperInt32::removeInterface(
 555     const sal_Int32 & rKey, const Reference< XInterface > & rListener )
 556 {
 557     ::osl::MutexGuard aGuard( rMutex );
 558
 559     if (!m_pMap)
 560         return 0;
 561     // search container with id nUik
 562     t_long2ptr * pMap = static_cast<t_long2ptr *>(m_pMap);
 563     t_long2ptr::iterator iter = findLong( pMap, rKey );
 564         // container found?
 565     if( iter != pMap->end() )
 566         return static_cast<OInterfaceContainerHelper*>((*iter).second)->removeInterface( rListener );
 567
 568     // no container with this id. Always return 0
 569     return 0;
 570 }
 571
 572 void OMultiTypeInterfaceContainerHelperInt32::disposeAndClear( const EventObject & rEvt )
 573 {
 574     t_long2ptr::size_type nSize = 0;
 575     std::unique_ptr<OInterfaceContainerHelper *[]> ppListenerContainers;
 576     {
 577         ::osl::MutexGuard aGuard( rMutex );
 578         if (!m_pMap)
 579             return;
 580
 581         t_long2ptr * pMap = static_cast<t_long2ptr *>(m_pMap);
 582         nSize = pMap->size();
 583         if( nSize )
 584         {
 585             typedef OInterfaceContainerHelper* ppp;
 586             ppListenerContainers.reset(new ppp[nSize]);
 587
 588             t_long2ptr::size_type i = 0;
 589             for (const auto& rItem : *pMap)
 590             {
 591                 ppListenerContainers[i++] = static_cast<OInterfaceContainerHelper*>(rItem.second);
 592             }
 593         }
 594     }
 595
 596     // create a copy, because do not fire event in a guarded section
 597     for( t_long2ptr::size_type i = 0;
 598             i < nSize; i++ )
 599     {
 600         if( ppListenerContainers[i] )
 601             ppListenerContainers[i]->disposeAndClear( rEvt );
 602     }
 603 }
 604
 605 void OMultiTypeInterfaceContainerHelperInt32::clear()
 606 {
 607     ::osl::MutexGuard aGuard( rMutex );
 608     if (!m_pMap)
 609         return;
 610     t_long2ptr * pMap = static_cast<t_long2ptr *>(m_pMap);
 611
 612     for (auto& rItem : *pMap)
 613     {
 614         static_cast<OInterfaceContainerHelper*>(rItem.second)->clear();
 615     }
 616 }
 617
 618 }
 619
 620 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */