LCOV - code coverage report
Current view: top level - cppuhelper/source - weak.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 168 181 92.8 %
Date: 2014-11-03 Functions: 38 39 97.4 %
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 <sal/config.h>
      21             : 
      22             : #include <boost/noncopyable.hpp>
      23             : #include <osl/mutex.hxx>
      24             : #include <cppuhelper/weakagg.hxx>
      25             : #include <cppuhelper/interfacecontainer.hxx>
      26             : #include <cppuhelper/exc_hlp.hxx>
      27             : 
      28             : using namespace osl;
      29             : using namespace com::sun::star::uno;
      30             : 
      31             : /** */ //for docpp
      32             : namespace cppu
      33             : {
      34             : 
      35             : // due to static Reflection destruction from usr, ther must be a mutex leak (#73272#)
      36   109334497 : inline static Mutex & getWeakMutex()
      37             : {
      38             :     static Mutex * s_pMutex = 0;
      39   109334497 :     if (! s_pMutex)
      40         642 :         s_pMutex = new Mutex();
      41   109334497 :     return *s_pMutex;
      42             : }
      43             : 
      44             : 
      45             : //-- OWeakConnectionPoint ----------------------------------------------------
      46             : 
      47             : class OWeakConnectionPoint: public XAdapter, private boost::noncopyable
      48             : {
      49             : public:
      50             :     /**
      51             :         Hold the weak object without an acquire (only the pointer).
      52             :      */
      53     2910891 :     OWeakConnectionPoint( OWeakObject* pObj )
      54             :         : m_aRefCount( 0 )
      55             :         , m_pObject(pObj)
      56     2910891 :         , m_aReferences( getWeakMutex() )
      57     2910891 :         {}
      58             : 
      59             :     // XInterface
      60             :     Any SAL_CALL        queryInterface( const Type & rType ) throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
      61             :     void SAL_CALL       acquire() throw() SAL_OVERRIDE;
      62             :     void SAL_CALL       release() throw() SAL_OVERRIDE;
      63             : 
      64             :     // XAdapter
      65             :     ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > SAL_CALL queryAdapted() throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
      66             :     void SAL_CALL addReference( const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XReference >& xRef ) throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
      67             :     void SAL_CALL removeReference( const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XReference >& xRef ) throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
      68             : 
      69             :     /// Called from the weak object if the reference count goes to zero.
      70             :     void SAL_CALL dispose() throw(::com::sun::star::uno::RuntimeException);
      71             : 
      72             : private:
      73     5811196 :     virtual ~OWeakConnectionPoint() {}
      74             : 
      75             :     /// The reference counter.
      76             :     oslInterlockedCount         m_aRefCount;
      77             :     /// The weak object
      78             :     OWeakObject*                m_pObject;
      79             :     /// The container to hold the weak references
      80             :     OInterfaceContainerHelper   m_aReferences;
      81             : };
      82             : 
      83             : // XInterface
      84           4 : Any SAL_CALL OWeakConnectionPoint::queryInterface( const Type & rType )
      85             :     throw(com::sun::star::uno::RuntimeException, std::exception)
      86             : {
      87             :     return ::cppu::queryInterface(
      88           4 :         rType, static_cast< XAdapter * >( this ), static_cast< XInterface * >( this ) );
      89             : }
      90             : 
      91             : // XInterface
      92    50189421 : void SAL_CALL OWeakConnectionPoint::acquire() throw()
      93             : {
      94    50189421 :     osl_atomic_increment( &m_aRefCount );
      95    50189421 : }
      96             : 
      97             : // XInterface
      98    50178605 : void SAL_CALL OWeakConnectionPoint::release() throw()
      99             : {
     100    50178605 :     if (! osl_atomic_decrement( &m_aRefCount ))
     101     2905598 :         delete this;
     102    50178605 : }
     103             : 
     104     2905598 : void SAL_CALL OWeakConnectionPoint::dispose() throw(::com::sun::star::uno::RuntimeException)
     105             : {
     106     2905598 :     Any ex;
     107     5811196 :     OInterfaceIteratorHelper aIt( m_aReferences );
     108     8735657 :     while( aIt.hasMoreElements() )
     109             :     {
     110             :         try
     111             :         {
     112     2924461 :             static_cast<XReference *>(aIt.next())->dispose();
     113             :         }
     114           0 :         catch (com::sun::star::lang::DisposedException &) {}
     115           0 :         catch (RuntimeException &)
     116             :         {
     117           0 :             ex = cppu::getCaughtException();
     118             :         }
     119             :     }
     120     2905598 :     if (ex.hasValue())
     121             :     {
     122           0 :         cppu::throwException(ex);
     123     2905598 :     }
     124     2905598 : }
     125             : 
     126             : // XInterface
     127    22086910 : Reference< XInterface > SAL_CALL OWeakConnectionPoint::queryAdapted() throw(::com::sun::star::uno::RuntimeException, std::exception)
     128             : {
     129    22086910 :     Reference< XInterface > ret;
     130             : 
     131    44173819 :     ClearableMutexGuard guard(getWeakMutex());
     132             : 
     133    22086910 :     if (m_pObject)
     134             :     {
     135    22086910 :         oslInterlockedCount n = osl_atomic_increment( &m_pObject->m_refCount );
     136             : 
     137    22086910 :         if (n > 1)
     138             :         {
     139             :             // The refence is incremented. The object cannot be destroyed.
     140             :             // Release the guard at the earliest point.
     141    21931954 :             guard.clear();
     142             :             // WeakObject has a (XInterface *) cast operator
     143    21931954 :             ret = *m_pObject;
     144    21931953 :             n = osl_atomic_decrement( &m_pObject->m_refCount );
     145             :         }
     146             :         else
     147             :             // Another thread wait in the dispose method at the guard
     148      154956 :             n = osl_atomic_decrement( &m_pObject->m_refCount );
     149             :     }
     150             : 
     151    44173817 :     return ret;
     152             : }
     153             : 
     154             : // XInterface
     155    11133587 : void SAL_CALL OWeakConnectionPoint::addReference(const Reference< XReference >& rRef)
     156             :     throw(::com::sun::star::uno::RuntimeException, std::exception)
     157             : {
     158    11133587 :     m_aReferences.addInterface( (const Reference< XInterface > &)rRef );
     159    11133587 : }
     160             : 
     161             : // XInterface
     162    11128066 : void SAL_CALL OWeakConnectionPoint::removeReference(const Reference< XReference >& rRef)
     163             :     throw(::com::sun::star::uno::RuntimeException, std::exception)
     164             : {
     165    11128066 :     m_aReferences.removeInterface( (const Reference< XInterface > &)rRef );
     166    11128066 : }
     167             : 
     168             : 
     169             : 
     170             : //-- OWeakObject -------------------------------------------------------
     171             : 
     172             : 
     173             : #ifdef _MSC_VER
     174             : // Accidentally occurs in msvc mapfile = > had to be outlined.
     175             : OWeakObject::OWeakObject()
     176             :     : m_refCount( 0 ),
     177             :       m_pWeakConnectionPoint( 0 )
     178             : {
     179             : }
     180             : #endif
     181             : 
     182             : // XInterface
     183    28828809 : Any SAL_CALL OWeakObject::queryInterface( const Type & rType ) throw(::com::sun::star::uno::RuntimeException, std::exception)
     184             : {
     185             :     return ::cppu::queryInterface(
     186             :         rType,
     187    28828809 :         static_cast< XWeak * >( this ), static_cast< XInterface * >( this ) );
     188             : }
     189             : 
     190             : // XInterface
     191   449900065 : void SAL_CALL OWeakObject::acquire() throw()
     192             : {
     193   449900065 :     osl_atomic_increment( &m_refCount );
     194   449900065 : }
     195             : 
     196             : // XInterface
     197   403444178 : void SAL_CALL OWeakObject::release() throw()
     198             : {
     199   403444178 :     if (osl_atomic_decrement( &m_refCount ) == 0) {
     200             :         // notify/clear all weak-refs before object's dtor is executed
     201             :         // (which may check weak-refs to this object):
     202    38387557 :         disposeWeakConnectionPoint();
     203             :         // destroy object:
     204    38387555 :         delete this;
     205             :     }
     206   403444178 : }
     207             : 
     208    39577086 : void OWeakObject::disposeWeakConnectionPoint()
     209             : {
     210             :     OSL_PRECOND( m_refCount == 0, "OWeakObject::disposeWeakConnectionPoint: only to be called with a ref count of 0!" );
     211    39577086 :     if (m_pWeakConnectionPoint != 0) {
     212     2905598 :         OWeakConnectionPoint * const p = m_pWeakConnectionPoint;
     213     2905598 :         m_pWeakConnectionPoint = 0;
     214             :         try {
     215     2905598 :             p->dispose();
     216             :         }
     217           0 :         catch (RuntimeException const& exc) {
     218             :             OSL_FAIL(
     219             :                 OUStringToOString(
     220             :                     exc.Message, RTL_TEXTENCODING_ASCII_US ).getStr() );
     221             :             static_cast<void>(exc);
     222             :         }
     223     2905598 :         p->release();
     224             :     }
     225    39577086 : }
     226             : 
     227    39126505 : OWeakObject::~OWeakObject()
     228             : {
     229    39126505 : }
     230             : 
     231             : // XWeak
     232    11133587 : Reference< XAdapter > SAL_CALL OWeakObject::queryAdapter()
     233             :     throw (::com::sun::star::uno::RuntimeException, std::exception)
     234             : {
     235    11133587 :     if (!m_pWeakConnectionPoint)
     236             :     {
     237             :         // only acquire mutex if member is not created
     238     2910891 :         MutexGuard aGuard( getWeakMutex() );
     239     2910891 :         if( !m_pWeakConnectionPoint )
     240             :         {
     241     2910891 :             OWeakConnectionPoint * p = new OWeakConnectionPoint(this);
     242     2910891 :             p->acquire();
     243     2910891 :             m_pWeakConnectionPoint = p;
     244     2910891 :         }
     245             :     }
     246             : 
     247    11133587 :     return m_pWeakConnectionPoint;
     248             : }
     249             : 
     250             : 
     251             : //-- OWeakAggObject ----------------------------------------------------
     252             : 
     253      600937 : OWeakAggObject::~OWeakAggObject()
     254             : {
     255      600937 : }
     256             : 
     257             : // XInterface
     258    26187904 : void OWeakAggObject::acquire() throw()
     259             : {
     260    26187904 :     Reference<XInterface > x( xDelegator );
     261    26187910 :     if (x.is())
     262     2369704 :         x->acquire();
     263             :     else
     264    23818206 :         OWeakObject::acquire();
     265    26187910 : }
     266             : 
     267             : // XInterface
     268    25469702 : void OWeakAggObject::release() throw()
     269             : {
     270    25469702 :     Reference<XInterface > x( xDelegator );
     271    25469703 :     if (x.is())
     272     2369316 :         x->release();
     273             :     else
     274    23100387 :         OWeakObject::release();
     275    25469703 : }
     276             : 
     277             : // XInterface
     278     4100066 : Any OWeakAggObject::queryInterface( const Type & rType ) throw(::com::sun::star::uno::RuntimeException, std::exception)
     279             : {
     280     4100066 :     Reference< XInterface > x( xDelegator ); // harden ref
     281     4100066 :     return (x.is() ? x->queryInterface( rType ) : queryAggregation( rType ));
     282             : }
     283             : 
     284             : // XAggregation
     285     1919745 : Any OWeakAggObject::queryAggregation( const Type & rType ) throw(::com::sun::star::uno::RuntimeException, std::exception)
     286             : {
     287             :     return ::cppu::queryInterface(
     288             :         rType,
     289             :         static_cast< XInterface * >( static_cast< OWeakObject * >( this ) ),
     290             :         static_cast< XAggregation * >( this ),
     291     1919745 :         static_cast< XWeak * >( this ) );
     292             : }
     293             : 
     294             : // XAggregation
     295       58810 : void OWeakAggObject::setDelegator( const Reference<XInterface > & rDelegator ) throw(::com::sun::star::uno::RuntimeException, std::exception)
     296             : {
     297       58810 :     xDelegator = rDelegator;
     298       58810 : }
     299             : 
     300             : }
     301             : 
     302             : /** */ //for docpp
     303             : namespace com
     304             : {
     305             : /** */ //for docpp
     306             : namespace sun
     307             : {
     308             : /** */ //for docpp
     309             : namespace star
     310             : {
     311             : /** */ //for docpp
     312             : namespace uno
     313             : {
     314             : 
     315             : 
     316             : 
     317             : //-- OWeakRefListener -----------------------------------------------------
     318             : 
     319             : class OWeakRefListener: public XReference, private boost::noncopyable
     320             : {
     321             : public:
     322             :     OWeakRefListener(const Reference< XInterface >& xInt);
     323             :     virtual ~OWeakRefListener();
     324             : 
     325             :     // XInterface
     326             :     Any SAL_CALL queryInterface( const Type & rType ) throw(RuntimeException, std::exception) SAL_OVERRIDE;
     327             :     void SAL_CALL acquire() throw() SAL_OVERRIDE;
     328             :     void SAL_CALL release() throw() SAL_OVERRIDE;
     329             : 
     330             :     // XReference
     331             :     void SAL_CALL   dispose() throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     332             : 
     333             :     /// The reference counter.
     334             :     oslInterlockedCount         m_aRefCount;
     335             :     /// The connection point of the weak object
     336             :     Reference< XAdapter >       m_XWeakConnectionPoint;
     337             : };
     338             : 
     339    11133587 : OWeakRefListener::OWeakRefListener(const Reference< XInterface >& xInt)
     340    11133587 :     : m_aRefCount( 1 )
     341             : {
     342             :     try
     343             :     {
     344    11133587 :     Reference< XWeak > xWeak( Reference< XWeak >::query( xInt ) );
     345             : 
     346    11133587 :     if (xWeak.is())
     347             :     {
     348    11133587 :         m_XWeakConnectionPoint = xWeak->queryAdapter();
     349             : 
     350    11133587 :         if (m_XWeakConnectionPoint.is())
     351             :         {
     352    11133587 :             m_XWeakConnectionPoint->addReference((XReference*)this);
     353             :         }
     354    11133587 :     }
     355             :     }
     356           0 :     catch (RuntimeException &) { OSL_ASSERT( false ); } // assert here, but no unexpected()
     357    11133587 :     osl_atomic_decrement( &m_aRefCount );
     358    11133587 : }
     359             : 
     360    33370638 : OWeakRefListener::~OWeakRefListener()
     361             : {
     362             :     try
     363             :     {
     364    11123546 :     if (m_XWeakConnectionPoint.is())
     365             :     {
     366           0 :         acquire(); // dont die again
     367           0 :         m_XWeakConnectionPoint->removeReference((XReference*)this);
     368             :     }
     369             :     }
     370           0 :     catch (RuntimeException &) { OSL_ASSERT( false ); } // assert here, but no unexpected()
     371    22247092 : }
     372             : 
     373             : // XInterface
     374          12 : Any SAL_CALL OWeakRefListener::queryInterface( const Type & rType ) throw(RuntimeException, std::exception)
     375             : {
     376             :     return ::cppu::queryInterface(
     377          12 :         rType, static_cast< XReference * >( this ), static_cast< XInterface * >( this ) );
     378             : }
     379             : 
     380             : // XInterface
     381    73281921 : void SAL_CALL OWeakRefListener::acquire() throw()
     382             : {
     383    73281921 :     osl_atomic_increment( &m_aRefCount );
     384    73281921 : }
     385             : 
     386             : // XInterface
     387    73266357 : void SAL_CALL OWeakRefListener::release() throw()
     388             : {
     389    73266357 :     if( ! osl_atomic_decrement( &m_aRefCount ) )
     390    11123546 :         delete this;
     391    73266357 : }
     392             : 
     393     2924461 : void SAL_CALL OWeakRefListener::dispose()
     394             :     throw(::com::sun::star::uno::RuntimeException, std::exception)
     395             : {
     396     2924461 :     Reference< XAdapter > xAdp;
     397             :     {
     398     2924461 :         MutexGuard guard(cppu::getWeakMutex());
     399     2924461 :         if( m_XWeakConnectionPoint.is() )
     400             :         {
     401     2924461 :             xAdp = m_XWeakConnectionPoint;
     402     2924461 :             m_XWeakConnectionPoint.clear();
     403     2924461 :         }
     404             :     }
     405             : 
     406     2924461 :     if( xAdp.is() )
     407     2924461 :         xAdp->removeReference((XReference*)this);
     408     2924461 : }
     409             : 
     410             : 
     411             : //-- WeakReferenceHelper ----------------------------------------------------------
     412             : 
     413     2676397 : WeakReferenceHelper::WeakReferenceHelper(const Reference< XInterface >& xInt)
     414     2676397 :     : m_pImpl( 0 )
     415             : {
     416     2676397 :     if (xInt.is())
     417             :     {
     418     2671909 :         m_pImpl = new OWeakRefListener(xInt);
     419     2671909 :         m_pImpl->acquire();
     420             :     }
     421     2676397 : }
     422             : 
     423     7712129 : WeakReferenceHelper::WeakReferenceHelper(const WeakReferenceHelper& rWeakRef)
     424     7712129 :     : m_pImpl( 0 )
     425             : {
     426     7712129 :     Reference< XInterface > xInt( rWeakRef.get() );
     427     7712129 :     if (xInt.is())
     428             :     {
     429     7600529 :         m_pImpl = new OWeakRefListener(xInt);
     430     7600529 :         m_pImpl->acquire();
     431     7712129 :     }
     432     7712129 : }
     433             : 
     434    14032622 : void WeakReferenceHelper::clear()
     435             : {
     436             :     try
     437             :     {
     438    14032622 :         if (m_pImpl)
     439             :         {
     440    11123546 :             if (m_pImpl->m_XWeakConnectionPoint.is())
     441             :             {
     442     8203605 :                 m_pImpl->m_XWeakConnectionPoint->removeReference(
     443     8203605 :                         (XReference*)m_pImpl);
     444     8203605 :                 m_pImpl->m_XWeakConnectionPoint.clear();
     445             :             }
     446    11123546 :             m_pImpl->release();
     447    11123546 :             m_pImpl = 0;
     448             :         }
     449             :     }
     450           0 :     catch (RuntimeException &) { OSL_ASSERT( false ); } // assert here, but no unexpected()
     451    14032622 : }
     452             : 
     453       58714 : WeakReferenceHelper& WeakReferenceHelper::operator=(const WeakReferenceHelper& rWeakRef)
     454             : {
     455       58714 :     if (this == &rWeakRef)
     456             :     {
     457           0 :         return *this;
     458             :     }
     459       58714 :     Reference< XInterface > xInt( rWeakRef.get() );
     460       58714 :     return operator = ( xInt );
     461             : }
     462             : 
     463             : WeakReferenceHelper & SAL_CALL
     464      997003 : WeakReferenceHelper::operator= (const Reference< XInterface > & xInt)
     465             : {
     466             :     try
     467             :     {
     468      997003 :         clear();
     469      997003 :         if (xInt.is())
     470             :         {
     471      861149 :             m_pImpl = new OWeakRefListener(xInt);
     472      861149 :             m_pImpl->acquire();
     473             :         }
     474             :     }
     475           0 :     catch (RuntimeException &) { OSL_ASSERT( false ); } // assert here, but no unexpected()
     476      997003 :     return *this;
     477             : }
     478             : 
     479    13018919 : WeakReferenceHelper::~WeakReferenceHelper()
     480             : {
     481    13018919 :     clear();
     482    13018920 : }
     483             : 
     484    78501365 : Reference< XInterface > WeakReferenceHelper::get() const
     485             : {
     486             :     try
     487             :     {
     488    78501365 :     Reference< XAdapter > xAdp;
     489             :     {
     490    78501358 :         MutexGuard guard(cppu::getWeakMutex());
     491    78501399 :         if( m_pImpl && m_pImpl->m_XWeakConnectionPoint.is() )
     492    22086910 :             xAdp = m_pImpl->m_XWeakConnectionPoint;
     493             :     }
     494             : 
     495    78501398 :     if (xAdp.is())
     496    22086910 :         return xAdp->queryAdapted();
     497             :     }
     498           0 :     catch (RuntimeException &) { OSL_ASSERT( false ); } // assert here, but no unexpected()
     499             : 
     500    56414488 :     return Reference< XInterface >();
     501             : }
     502             : 
     503             : }
     504             : }
     505             : }
     506             : }
     507             : 
     508             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10