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