LCOV - code coverage report
Current view: top level - cppuhelper/source - weak.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 48 181 26.5 %
Date: 2014-04-14 Functions: 14 39 35.9 %
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         186 : inline static Mutex & getWeakMutex() SAL_THROW(())
      37             : {
      38             :     static Mutex * s_pMutex = 0;
      39         186 :     if (! s_pMutex)
      40           1 :         s_pMutex = new Mutex();
      41         186 :     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           0 :     OWeakConnectionPoint( OWeakObject* pObj ) SAL_THROW(())
      54             :         : m_aRefCount( 0 )
      55             :         , m_pObject(pObj)
      56           0 :         , m_aReferences( getWeakMutex() )
      57           0 :         {}
      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           0 :     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           0 : Any SAL_CALL OWeakConnectionPoint::queryInterface( const Type & rType )
      85             :     throw(com::sun::star::uno::RuntimeException, std::exception)
      86             : {
      87             :     return ::cppu::queryInterface(
      88           0 :         rType, static_cast< XAdapter * >( this ), static_cast< XInterface * >( this ) );
      89             : }
      90             : 
      91             : // XInterface
      92           0 : void SAL_CALL OWeakConnectionPoint::acquire() throw()
      93             : {
      94           0 :     osl_atomic_increment( &m_aRefCount );
      95           0 : }
      96             : 
      97             : // XInterface
      98           0 : void SAL_CALL OWeakConnectionPoint::release() throw()
      99             : {
     100           0 :     if (! osl_atomic_decrement( &m_aRefCount ))
     101           0 :         delete this;
     102           0 : }
     103             : 
     104           0 : void SAL_CALL OWeakConnectionPoint::dispose() throw(::com::sun::star::uno::RuntimeException)
     105             : {
     106           0 :     Any ex;
     107           0 :     OInterfaceIteratorHelper aIt( m_aReferences );
     108           0 :     while( aIt.hasMoreElements() )
     109             :     {
     110             :         try
     111             :         {
     112           0 :             ((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           0 :     if (ex.hasValue())
     121             :     {
     122           0 :         cppu::throwException(ex);
     123           0 :     }
     124           0 : }
     125             : 
     126             : // XInterface
     127           0 : Reference< XInterface > SAL_CALL OWeakConnectionPoint::queryAdapted() throw(::com::sun::star::uno::RuntimeException, std::exception)
     128             : {
     129           0 :     Reference< XInterface > ret;
     130             : 
     131           0 :     ClearableMutexGuard guard(getWeakMutex());
     132             : 
     133           0 :     if (m_pObject)
     134             :     {
     135           0 :         oslInterlockedCount n = osl_atomic_increment( &m_pObject->m_refCount );
     136             : 
     137           0 :         if (n > 1)
     138             :         {
     139             :             // The refence is incremented. The object cannot be destroyed.
     140             :             // Release the guard at the earliest point.
     141           0 :             guard.clear();
     142             :             // WeakObject has a (XInterface *) cast operator
     143           0 :             ret = *m_pObject;
     144           0 :             n = osl_atomic_decrement( &m_pObject->m_refCount );
     145             :         }
     146             :         else
     147             :             // Another thread wait in the dispose method at the guard
     148           0 :             n = osl_atomic_decrement( &m_pObject->m_refCount );
     149             :     }
     150             : 
     151           0 :     return ret;
     152             : }
     153             : 
     154             : // XInterface
     155           0 : void SAL_CALL OWeakConnectionPoint::addReference(const Reference< XReference >& rRef)
     156             :     throw(::com::sun::star::uno::RuntimeException, std::exception)
     157             : {
     158           0 :     m_aReferences.addInterface( (const Reference< XInterface > &)rRef );
     159           0 : }
     160             : 
     161             : // XInterface
     162           0 : void SAL_CALL OWeakConnectionPoint::removeReference(const Reference< XReference >& rRef)
     163             :     throw(::com::sun::star::uno::RuntimeException, std::exception)
     164             : {
     165           0 :     m_aReferences.removeInterface( (const Reference< XInterface > &)rRef );
     166           0 : }
     167             : 
     168             : 
     169             : 
     170             : //-- OWeakObject -------------------------------------------------------
     171             : 
     172             : 
     173             : #ifdef _MSC_VER
     174             : // Accidentally occurs in msvc mapfile = > had to be outlined.
     175             : OWeakObject::OWeakObject() SAL_THROW(())
     176             :     : m_refCount( 0 ),
     177             :       m_pWeakConnectionPoint( 0 )
     178             : {
     179             : }
     180             : #endif
     181             : 
     182             : // XInterface
     183          23 : Any SAL_CALL OWeakObject::queryInterface( const Type & rType ) throw(::com::sun::star::uno::RuntimeException, std::exception)
     184             : {
     185             :     return ::cppu::queryInterface(
     186             :         rType,
     187          23 :         static_cast< XWeak * >( this ), static_cast< XInterface * >( this ) );
     188             : }
     189             : 
     190             : // XInterface
     191         813 : void SAL_CALL OWeakObject::acquire() throw()
     192             : {
     193         813 :     osl_atomic_increment( &m_refCount );
     194         813 : }
     195             : 
     196             : // XInterface
     197         583 : void SAL_CALL OWeakObject::release() throw()
     198             : {
     199         583 :     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         100 :         disposeWeakConnectionPoint();
     203             :         // destroy object:
     204         100 :         delete this;
     205             :     }
     206         583 : }
     207             : 
     208         108 : void OWeakObject::disposeWeakConnectionPoint()
     209             : {
     210             :     OSL_PRECOND( m_refCount == 0, "OWeakObject::disposeWeakConnectionPoint: only to be called with a ref count of 0!" );
     211         108 :     if (m_pWeakConnectionPoint != 0) {
     212           0 :         OWeakConnectionPoint * const p = m_pWeakConnectionPoint;
     213           0 :         m_pWeakConnectionPoint = 0;
     214             :         try {
     215           0 :             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           0 :         p->release();
     224             :     }
     225         108 : }
     226             : 
     227         100 : OWeakObject::~OWeakObject() SAL_THROW( (RuntimeException) )
     228             : {
     229         100 : }
     230             : 
     231             : // XWeak
     232           0 : Reference< XAdapter > SAL_CALL OWeakObject::queryAdapter()
     233             :     throw (::com::sun::star::uno::RuntimeException, std::exception)
     234             : {
     235           0 :     if (!m_pWeakConnectionPoint)
     236             :     {
     237             :         // only acquire mutex if member is not created
     238           0 :         MutexGuard aGuard( getWeakMutex() );
     239           0 :         if( !m_pWeakConnectionPoint )
     240             :         {
     241           0 :             OWeakConnectionPoint * p = new OWeakConnectionPoint(this);
     242           0 :             p->acquire();
     243           0 :             m_pWeakConnectionPoint = p;
     244           0 :         }
     245             :     }
     246             : 
     247           0 :     return m_pWeakConnectionPoint;
     248             : }
     249             : 
     250             : 
     251             : //-- OWeakAggObject ----------------------------------------------------
     252             : 
     253           5 : OWeakAggObject::~OWeakAggObject() SAL_THROW( (RuntimeException) )
     254             : {
     255           5 : }
     256             : 
     257             : // XInterface
     258          60 : void OWeakAggObject::acquire() throw()
     259             : {
     260          60 :     Reference<XInterface > x( xDelegator );
     261          60 :     if (x.is())
     262           0 :         x->acquire();
     263             :     else
     264          60 :         OWeakObject::acquire();
     265          60 : }
     266             : 
     267             : // XInterface
     268          56 : void OWeakAggObject::release() throw()
     269             : {
     270          56 :     Reference<XInterface > x( xDelegator );
     271          56 :     if (x.is())
     272           0 :         x->release();
     273             :     else
     274          56 :         OWeakObject::release();
     275          56 : }
     276             : 
     277             : // XInterface
     278          10 : Any OWeakAggObject::queryInterface( const Type & rType ) throw(::com::sun::star::uno::RuntimeException, std::exception)
     279             : {
     280          10 :     Reference< XInterface > x( xDelegator ); // harden ref
     281          10 :     return (x.is() ? x->queryInterface( rType ) : queryAggregation( rType ));
     282             : }
     283             : 
     284             : // XAggregation
     285           9 : 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           9 :         static_cast< XWeak * >( this ) );
     292             : }
     293             : 
     294             : // XAggregation
     295           0 : void OWeakAggObject::setDelegator( const Reference<XInterface > & rDelegator ) throw(::com::sun::star::uno::RuntimeException, std::exception)
     296             : {
     297           0 :     xDelegator = rDelegator;
     298           0 : }
     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) SAL_THROW(());
     323             :     virtual ~OWeakRefListener() SAL_THROW(());
     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           0 : OWeakRefListener::OWeakRefListener(const Reference< XInterface >& xInt) SAL_THROW(())
     340           0 :     : m_aRefCount( 1 )
     341             : {
     342             :     try
     343             :     {
     344           0 :     Reference< XWeak > xWeak( Reference< XWeak >::query( xInt ) );
     345             : 
     346           0 :     if (xWeak.is())
     347             :     {
     348           0 :         m_XWeakConnectionPoint = xWeak->queryAdapter();
     349             : 
     350           0 :         if (m_XWeakConnectionPoint.is())
     351             :         {
     352           0 :             m_XWeakConnectionPoint->addReference((XReference*)this);
     353             :         }
     354           0 :     }
     355             :     }
     356           0 :     catch (RuntimeException &) { OSL_ASSERT( false ); } // assert here, but no unexpected()
     357           0 :     osl_atomic_decrement( &m_aRefCount );
     358           0 : }
     359             : 
     360           0 : OWeakRefListener::~OWeakRefListener() SAL_THROW(())
     361             : {
     362             :     try
     363             :     {
     364           0 :     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           0 : }
     372             : 
     373             : // XInterface
     374           0 : Any SAL_CALL OWeakRefListener::queryInterface( const Type & rType ) throw(RuntimeException, std::exception)
     375             : {
     376             :     return ::cppu::queryInterface(
     377           0 :         rType, static_cast< XReference * >( this ), static_cast< XInterface * >( this ) );
     378             : }
     379             : 
     380             : // XInterface
     381           0 : void SAL_CALL OWeakRefListener::acquire() throw()
     382             : {
     383           0 :     osl_atomic_increment( &m_aRefCount );
     384           0 : }
     385             : 
     386             : // XInterface
     387           0 : void SAL_CALL OWeakRefListener::release() throw()
     388             : {
     389           0 :     if( ! osl_atomic_decrement( &m_aRefCount ) )
     390           0 :         delete this;
     391           0 : }
     392             : 
     393           0 : void SAL_CALL OWeakRefListener::dispose()
     394             :     throw(::com::sun::star::uno::RuntimeException, std::exception)
     395             : {
     396           0 :     Reference< XAdapter > xAdp;
     397             :     {
     398           0 :         MutexGuard guard(cppu::getWeakMutex());
     399           0 :         if( m_XWeakConnectionPoint.is() )
     400             :         {
     401           0 :             xAdp = m_XWeakConnectionPoint;
     402           0 :             m_XWeakConnectionPoint.clear();
     403           0 :         }
     404             :     }
     405             : 
     406           0 :     if( xAdp.is() )
     407           0 :         xAdp->removeReference((XReference*)this);
     408           0 : }
     409             : 
     410             : 
     411             : //-- WeakReferenceHelper ----------------------------------------------------------
     412             : 
     413           0 : WeakReferenceHelper::WeakReferenceHelper(const Reference< XInterface >& xInt) SAL_THROW(())
     414           0 :     : m_pImpl( 0 )
     415             : {
     416           0 :     if (xInt.is())
     417             :     {
     418           0 :         m_pImpl = new OWeakRefListener(xInt);
     419           0 :         m_pImpl->acquire();
     420             :     }
     421           0 : }
     422             : 
     423           0 : WeakReferenceHelper::WeakReferenceHelper(const WeakReferenceHelper& rWeakRef) SAL_THROW(())
     424           0 :     : m_pImpl( 0 )
     425             : {
     426           0 :     Reference< XInterface > xInt( rWeakRef.get() );
     427           0 :     if (xInt.is())
     428             :     {
     429           0 :         m_pImpl = new OWeakRefListener(xInt);
     430           0 :         m_pImpl->acquire();
     431           0 :     }
     432           0 : }
     433             : 
     434           5 : void WeakReferenceHelper::clear() SAL_THROW(())
     435             : {
     436             :     try
     437             :     {
     438           5 :         if (m_pImpl)
     439             :         {
     440           0 :             if (m_pImpl->m_XWeakConnectionPoint.is())
     441             :             {
     442           0 :                 m_pImpl->m_XWeakConnectionPoint->removeReference(
     443           0 :                         (XReference*)m_pImpl);
     444           0 :                 m_pImpl->m_XWeakConnectionPoint.clear();
     445             :             }
     446           0 :             m_pImpl->release();
     447           0 :             m_pImpl = 0;
     448             :         }
     449             :     }
     450           0 :     catch (RuntimeException &) { OSL_ASSERT( false ); } // assert here, but no unexpected()
     451           5 : }
     452             : 
     453           0 : WeakReferenceHelper& WeakReferenceHelper::operator=(const WeakReferenceHelper& rWeakRef) SAL_THROW(())
     454             : {
     455           0 :     if (this == &rWeakRef)
     456             :     {
     457           0 :         return *this;
     458             :     }
     459           0 :     Reference< XInterface > xInt( rWeakRef.get() );
     460           0 :     return operator = ( xInt );
     461             : }
     462             : 
     463             : WeakReferenceHelper & SAL_CALL
     464           0 : WeakReferenceHelper::operator= (const Reference< XInterface > & xInt)
     465             : SAL_THROW(())
     466             : {
     467             :     try
     468             :     {
     469           0 :         clear();
     470           0 :         if (xInt.is())
     471             :         {
     472           0 :             m_pImpl = new OWeakRefListener(xInt);
     473           0 :             m_pImpl->acquire();
     474             :         }
     475             :     }
     476           0 :     catch (RuntimeException &) { OSL_ASSERT( false ); } // assert here, but no unexpected()
     477           0 :     return *this;
     478             : }
     479             : 
     480           5 : WeakReferenceHelper::~WeakReferenceHelper() SAL_THROW(())
     481             : {
     482           5 :     clear();
     483           5 : }
     484             : 
     485         186 : Reference< XInterface > WeakReferenceHelper::get() const SAL_THROW(())
     486             : {
     487             :     try
     488             :     {
     489         186 :     Reference< XAdapter > xAdp;
     490             :     {
     491         186 :         MutexGuard guard(cppu::getWeakMutex());
     492         186 :         if( m_pImpl && m_pImpl->m_XWeakConnectionPoint.is() )
     493           0 :             xAdp = m_pImpl->m_XWeakConnectionPoint;
     494             :     }
     495             : 
     496         186 :     if (xAdp.is())
     497           0 :         return xAdp->queryAdapted();
     498             :     }
     499           0 :     catch (RuntimeException &) { OSL_ASSERT( false ); } // assert here, but no unexpected()
     500             : 
     501         186 :     return Reference< XInterface >();
     502             : }
     503             : 
     504             : }
     505             : }
     506             : }
     507             : }
     508             : 
     509             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10