implbase.cxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */
 
#include <cppuhelper/compbase_ex.hxx>
#include <cppuhelper/exc_hlp.hxx>
#include <osl/diagnose.h>
#include <sal/log.hxx>
 
#include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
#include <com/sun/star/uno/RuntimeException.hpp>
 
using namespace ::osl;
using namespace ::com::sun::star;
using namespace ::com::sun::star::uno;
 
 
namespace cppu
{
 
// WeakComponentImplHelperBase
 
WeakComponentImplHelperBase::WeakComponentImplHelperBase( Mutex & rMutex )
    : rBHelper( rMutex )
{
}
 
WeakComponentImplHelperBase::~WeakComponentImplHelperBase()
{
}
 
void WeakComponentImplHelperBase::disposing()
{
}
 
Any WeakComponentImplHelperBase::queryInterface( Type const & rType )
{
    if (rType == cppu::UnoType<lang::XComponent>::get())
    {
        void * p = static_cast< lang::XComponent * >( this );
        return Any( &p, rType );
    }
    return OWeakObject::queryInterface( rType );
}
 
void WeakComponentImplHelperBase::acquire()
    noexcept
{
    OWeakObject::acquire();
}
 
void WeakComponentImplHelperBase::release()
    noexcept
{
    if (osl_atomic_decrement( &m_refCount ) != 0)
        return;
 
    // ensure no other references are created, via the weak connection point, from now on
    disposeWeakConnectionPoint();
    // restore reference count:
    osl_atomic_increment( &m_refCount );
    if (! rBHelper.bDisposed) {
        try {
            dispose();
        }
        catch (RuntimeException const& exc) { // don't break throw ()
            SAL_WARN( "cppuhelper", exc );
        }
        OSL_ASSERT( rBHelper.bDisposed );
    }
    OWeakObject::release();
}
 
void WeakComponentImplHelperBase::dispose()
{
    ClearableMutexGuard aGuard( rBHelper.rMutex );
    if (rBHelper.bDisposed || rBHelper.bInDispose)
        return;
 
    rBHelper.bInDispose = true;
    aGuard.clear();
    try
    {
        // side effect: keeping a reference to this
        lang::EventObject aEvt( static_cast< OWeakObject * >( this ) );
        try
        {
            rBHelper.aLC.disposeAndClear( aEvt );
            disposing();
        }
        catch (...)
        {
            MutexGuard aGuard2( rBHelper.rMutex );
            // bDisposed and bInDispose must be set in this order:
            rBHelper.bDisposed = true;
            rBHelper.bInDispose = false;
            throw;
        }
        MutexGuard aGuard2( rBHelper.rMutex );
        // bDisposed and bInDispose must be set in this order:
        rBHelper.bDisposed = true;
        rBHelper.bInDispose = false;
    }
    catch (RuntimeException &)
    {
        throw;
    }
    catch (Exception & exc)
    {
        css::uno::Any anyEx = cppu::getCaughtException();
        throw lang::WrappedTargetRuntimeException(
            "unexpected UNO exception caught: " + exc.Message,
            nullptr, anyEx );
    }
}
 
void WeakComponentImplHelperBase::addEventListener(
    Reference< lang::XEventListener > const & xListener )
{
    ClearableMutexGuard aGuard( rBHelper.rMutex );
    if (rBHelper.bDisposed || rBHelper.bInDispose)
    {
        aGuard.clear();
        lang::EventObject aEvt( static_cast< OWeakObject * >( this ) );
        xListener->disposing( aEvt );
    }
    else
    {
        rBHelper.addListener( cppu::UnoType<decltype(xListener)>::get(), xListener );
    }
}
 
void WeakComponentImplHelperBase::removeEventListener(
    Reference< lang::XEventListener > const & xListener )
{
    rBHelper.removeListener( cppu::UnoType<decltype(xListener)>::get(), xListener );
}
 
// WeakAggComponentImplHelperBase
 
WeakAggComponentImplHelperBase::WeakAggComponentImplHelperBase( Mutex & rMutex )
    : rBHelper( rMutex )
{
}
 
WeakAggComponentImplHelperBase::~WeakAggComponentImplHelperBase()
{
}
 
void WeakAggComponentImplHelperBase::disposing()
{
}
 
Any WeakAggComponentImplHelperBase::queryInterface( Type const & rType )
{
    return OWeakAggObject::queryInterface( rType );
}
 
Any WeakAggComponentImplHelperBase::queryAggregation( Type const & rType )
{
    if (rType == cppu::UnoType<lang::XComponent>::get())
    {
        void * p = static_cast< lang::XComponent * >( this );
        return Any( &p, rType );
    }
    return OWeakAggObject::queryAggregation( rType );
}
 
void WeakAggComponentImplHelperBase::acquire()
    noexcept
{
    OWeakAggObject::acquire();
}
 
void WeakAggComponentImplHelperBase::release()
    noexcept
{
    Reference<XInterface> const xDelegator_(xDelegator);
    if (xDelegator_.is()) {
        OWeakAggObject::release();
    }
    else if (osl_atomic_decrement( &m_refCount ) == 0) {
        // ensure no other references are created, via the weak connection point, from now on
        disposeWeakConnectionPoint();
        // restore reference count:
        osl_atomic_increment( &m_refCount );
        if (! rBHelper.bDisposed) {
            try {
                dispose();
            }
            catch (RuntimeException const& exc) { // don't break throw ()
                SAL_WARN( "cppuhelper", exc );
            }
            OSL_ASSERT( rBHelper.bDisposed );
        }
        OWeakAggObject::release();
    }
}
 
void WeakAggComponentImplHelperBase::dispose()
{
    ClearableMutexGuard aGuard( rBHelper.rMutex );
    if (rBHelper.bDisposed || rBHelper.bInDispose)
        return;
 
    rBHelper.bInDispose = true;
    aGuard.clear();
    try
    {
        // side effect: keeping a reference to this
        lang::EventObject aEvt( static_cast< OWeakObject * >( this ) );
        try
        {
            rBHelper.aLC.disposeAndClear( aEvt );
            disposing();
        }
        catch (...)
        {
            MutexGuard aGuard2( rBHelper.rMutex );
            // bDisposed and bInDispose must be set in this order:
            rBHelper.bDisposed = true;
            rBHelper.bInDispose = false;
            throw;
        }
        MutexGuard aGuard2( rBHelper.rMutex );
        // bDisposed and bInDispose must be set in this order:
        rBHelper.bDisposed = true;
        rBHelper.bInDispose = false;
    }
    catch (RuntimeException &)
    {
        throw;
    }
    catch (Exception & exc)
    {
        css::uno::Any anyEx = cppu::getCaughtException();
        throw lang::WrappedTargetRuntimeException(
            "unexpected UNO exception caught: " + exc.Message,
            nullptr, anyEx );
    }
}
 
void WeakAggComponentImplHelperBase::addEventListener(
    Reference< lang::XEventListener > const & xListener )
{
    ClearableMutexGuard aGuard( rBHelper.rMutex );
    if (rBHelper.bDisposed || rBHelper.bInDispose)
    {
        aGuard.clear();
        lang::EventObject aEvt( static_cast< OWeakObject * >( this ) );
        xListener->disposing( aEvt );
    }
    else
    {
        rBHelper.addListener( cppu::UnoType<decltype(xListener)>::get(), xListener );
    }
}
 
void WeakAggComponentImplHelperBase::removeEventListener(
    Reference< lang::XEventListener > const & xListener )
{
    // if we have disposed, then we have cleared the list already
    MutexGuard aGuard( rBHelper.rMutex );
    if (!rBHelper.bDisposed)
        rBHelper.removeListener( cppu::UnoType<decltype(xListener)>::get(), xListener );
}
 
}
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */