cppuhelper/source/implbase.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 #include <cppuhelper/compbase_ex.hxx>
  21 #include <cppuhelper/exc_hlp.hxx>
  22 #include <osl/diagnose.h>
  23 #include <sal/log.hxx>
  24 #include <rtl/instance.hxx>
  25 #include <rtl/string.hxx>
  26
  27 #include <com/sun/star/lang/XComponent.hpp>
  28 #include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
  29 #include <com/sun/star/uno/RuntimeException.hpp>
  30
  31 using namespace ::osl;
  32 using namespace ::com::sun::star;
  33 using namespace ::com::sun::star::uno;
  34
  35
  36 namespace cppu
  37 {
  38
  39 // WeakComponentImplHelperBase
  40
  41 WeakComponentImplHelperBase::WeakComponentImplHelperBase( Mutex & rMutex )
  42     : rBHelper( rMutex )
  43 {
  44 }
  45
  46 WeakComponentImplHelperBase::~WeakComponentImplHelperBase()
  47 {
  48 }
  49
  50 void WeakComponentImplHelperBase::disposing()
  51 {
  52 }
  53
  54 Any WeakComponentImplHelperBase::queryInterface( Type const & rType )
  55 {
  56     if (rType == cppu::UnoType<lang::XComponent>::get())
  57     {
  58         void * p = static_cast< lang::XComponent * >( this );
  59         return Any( &p, rType );
  60     }
  61     return OWeakObject::queryInterface( rType );
  62 }
  63
  64 void WeakComponentImplHelperBase::acquire()
  65     throw ()
  66 {
  67     OWeakObject::acquire();
  68 }
  69
  70 void WeakComponentImplHelperBase::release()
  71     throw ()
  72 {
  73     if (osl_atomic_decrement( &m_refCount ) == 0) {
  74         // ensure no other references are created, via the weak connection point, from now on
  75         disposeWeakConnectionPoint();
  76         // restore reference count:
  77         osl_atomic_increment( &m_refCount );
  78         if (! rBHelper.bDisposed) {
  79             try {
  80                 dispose();
  81             }
  82             catch (RuntimeException const& exc) { // don't break throw ()
  83                 SAL_WARN( "cppuhelper", exc );
  84             }
  85             OSL_ASSERT( rBHelper.bDisposed );
  86         }
  87         OWeakObject::release();
  88     }
  89 }
  90
  91 void WeakComponentImplHelperBase::dispose()
  92 {
  93     ClearableMutexGuard aGuard( rBHelper.rMutex );
  94     if (!rBHelper.bDisposed && !rBHelper.bInDispose)
  95     {
  96         rBHelper.bInDispose = true;
  97         aGuard.clear();
  98         try
  99         {
 100             // side effect: keeping a reference to this
 101             lang::EventObject aEvt( static_cast< OWeakObject * >( this ) );
 102             try
 103             {
 104                 rBHelper.aLC.disposeAndClear( aEvt );
 105                 disposing();
 106             }
 107             catch (...)
 108             {
 109                 MutexGuard aGuard2( rBHelper.rMutex );
 110                 // bDisposed and bInDispose must be set in this order:
 111                 rBHelper.bDisposed = true;
 112                 rBHelper.bInDispose = false;
 113                 throw;
 114             }
 115             MutexGuard aGuard2( rBHelper.rMutex );
 116             // bDisposed and bInDispose must be set in this order:
 117             rBHelper.bDisposed = true;
 118             rBHelper.bInDispose = false;
 119         }
 120         catch (RuntimeException &)
 121         {
 122             throw;
 123         }
 124         catch (Exception & exc)
 125         {
 126             css::uno::Any anyEx = cppu::getCaughtException();
 127             throw lang::WrappedTargetRuntimeException(
 128                 "unexpected UNO exception caught: " + exc.Message,
 129                 nullptr, anyEx );
 130         }
 131     }
 132 }
 133
 134 void WeakComponentImplHelperBase::addEventListener(
 135     Reference< lang::XEventListener > const & xListener )
 136 {
 137     ClearableMutexGuard aGuard( rBHelper.rMutex );
 138     if (rBHelper.bDisposed || rBHelper.bInDispose)
 139     {
 140         aGuard.clear();
 141         lang::EventObject aEvt( static_cast< OWeakObject * >( this ) );
 142         xListener->disposing( aEvt );
 143     }
 144     else
 145     {
 146         rBHelper.addListener( cppu::UnoType<decltype(xListener)>::get(), xListener );
 147     }
 148 }
 149
 150 void WeakComponentImplHelperBase::removeEventListener(
 151     Reference< lang::XEventListener > const & xListener )
 152 {
 153     rBHelper.removeListener( cppu::UnoType<decltype(xListener)>::get(), xListener );
 154 }
 155
 156 // WeakAggComponentImplHelperBase
 157
 158 WeakAggComponentImplHelperBase::WeakAggComponentImplHelperBase( Mutex & rMutex )
 159     : rBHelper( rMutex )
 160 {
 161 }
 162
 163 WeakAggComponentImplHelperBase::~WeakAggComponentImplHelperBase()
 164 {
 165 }
 166
 167 void WeakAggComponentImplHelperBase::disposing()
 168 {
 169 }
 170
 171 Any WeakAggComponentImplHelperBase::queryInterface( Type const & rType )
 172 {
 173     return OWeakAggObject::queryInterface( rType );
 174 }
 175
 176 Any WeakAggComponentImplHelperBase::queryAggregation( Type const & rType )
 177 {
 178     if (rType == cppu::UnoType<lang::XComponent>::get())
 179     {
 180         void * p = static_cast< lang::XComponent * >( this );
 181         return Any( &p, rType );
 182     }
 183     return OWeakAggObject::queryAggregation( rType );
 184 }
 185
 186 void WeakAggComponentImplHelperBase::acquire()
 187     throw ()
 188 {
 189     OWeakAggObject::acquire();
 190 }
 191
 192 void WeakAggComponentImplHelperBase::release()
 193     throw ()
 194 {
 195     Reference<XInterface> const xDelegator_(xDelegator);
 196     if (xDelegator_.is()) {
 197         OWeakAggObject::release();
 198     }
 199     else if (osl_atomic_decrement( &m_refCount ) == 0) {
 200         // ensure no other references are created, via the weak connection point, from now on
 201         disposeWeakConnectionPoint();
 202         // restore reference count:
 203         osl_atomic_increment( &m_refCount );
 204         if (! rBHelper.bDisposed) {
 205             try {
 206                 dispose();
 207             }
 208             catch (RuntimeException const& exc) { // don't break throw ()
 209                 SAL_WARN( "cppuhelper", exc );
 210             }
 211             OSL_ASSERT( rBHelper.bDisposed );
 212         }
 213         OWeakAggObject::release();
 214     }
 215 }
 216
 217 void WeakAggComponentImplHelperBase::dispose()
 218 {
 219     ClearableMutexGuard aGuard( rBHelper.rMutex );
 220     if (!rBHelper.bDisposed && !rBHelper.bInDispose)
 221     {
 222         rBHelper.bInDispose = true;
 223         aGuard.clear();
 224         try
 225         {
 226             // side effect: keeping a reference to this
 227             lang::EventObject aEvt( static_cast< OWeakObject * >( this ) );
 228             try
 229             {
 230                 rBHelper.aLC.disposeAndClear( aEvt );
 231                 disposing();
 232             }
 233             catch (...)
 234             {
 235                 MutexGuard aGuard2( rBHelper.rMutex );
 236                 // bDisposed and bInDispose must be set in this order:
 237                 rBHelper.bDisposed = true;
 238                 rBHelper.bInDispose = false;
 239                 throw;
 240             }
 241             MutexGuard aGuard2( rBHelper.rMutex );
 242             // bDisposed and bInDispose must be set in this order:
 243             rBHelper.bDisposed = true;
 244             rBHelper.bInDispose = false;
 245         }
 246         catch (RuntimeException &)
 247         {
 248             throw;
 249         }
 250         catch (Exception & exc)
 251         {
 252             css::uno::Any anyEx = cppu::getCaughtException();
 253             throw lang::WrappedTargetRuntimeException(
 254                 "unexpected UNO exception caught: " + exc.Message,
 255                 nullptr, anyEx );
 256         }
 257     }
 258 }
 259
 260 void WeakAggComponentImplHelperBase::addEventListener(
 261     Reference< lang::XEventListener > const & xListener )
 262 {
 263     ClearableMutexGuard aGuard( rBHelper.rMutex );
 264     if (rBHelper.bDisposed || rBHelper.bInDispose)
 265     {
 266         aGuard.clear();
 267         lang::EventObject aEvt( static_cast< OWeakObject * >( this ) );
 268         xListener->disposing( aEvt );
 269     }
 270     else
 271     {
 272         rBHelper.addListener( cppu::UnoType<decltype(xListener)>::get(), xListener );
 273     }
 274 }
 275
 276 void WeakAggComponentImplHelperBase::removeEventListener(
 277     Reference< lang::XEventListener > const & xListener )
 278 {
 279     // if we have disposed, then we have cleared the list already
 280     MutexGuard aGuard( rBHelper.rMutex );
 281     if (!rBHelper.bDisposed)
 282         rBHelper.removeListener( cppu::UnoType<decltype(xListener)>::get(), xListener );
 283 }
 284
 285 }
 286
 287 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */