diff options
Diffstat (limited to '')
| -rw-r--r-- | chart2/source/inc/LifeTime.hxx | 213 |
1 files changed, 213 insertions, 0 deletions
diff --git a/chart2/source/inc/LifeTime.hxx b/chart2/source/inc/LifeTime.hxx new file mode 100644 index 000000000..613d92314 --- /dev/null +++ b/chart2/source/inc/LifeTime.hxx @@ -0,0 +1,213 @@ +/* -*- 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 . + */ +#pragma once + +#include <osl/mutex.hxx> +#include <osl/conditn.hxx> +#include <comphelper/multicontainer2.hxx> +#include "charttoolsdllapi.hxx" + +namespace com::sun::star::lang { class XComponent; } +namespace com::sun::star::util { class CloseVetoException; } +namespace com::sun::star::util { class XCloseListener; } +namespace com::sun::star::util { class XCloseable; } + +namespace apphelper +{ + +class OOO_DLLPUBLIC_CHARTTOOLS LifeTimeManager +{ +friend class LifeTimeGuard; +protected: + mutable ::osl::Mutex m_aAccessMutex; +public: + LifeTimeManager( css::lang::XComponent* pComponent ); + virtual ~LifeTimeManager(); + + bool impl_isDisposed( bool bAssert=true ); + /// @throws css::uno::RuntimeException + bool dispose(); + +public: + ::comphelper::OMultiTypeInterfaceContainerHelper2 m_aListenerContainer; + +protected: + SAL_DLLPRIVATE virtual bool impl_canStartApiCall(); + SAL_DLLPRIVATE virtual void impl_apiCallCountReachedNull(){} + + SAL_DLLPRIVATE void impl_registerApiCall(bool bLongLastingCall); + SAL_DLLPRIVATE void impl_unregisterApiCall(bool bLongLastingCall); + +protected: + css::lang::XComponent* m_pComponent; + + ::osl::Condition m_aNoAccessCountCondition; + sal_Int32 m_nAccessCount; + + bool volatile m_bDisposed; + bool volatile m_bInDispose; + + ::osl::Condition m_aNoLongLastingCallCountCondition; + sal_Int32 m_nLongLastingCallCount; +}; + +class CloseableLifeTimeManager final : public LifeTimeManager +{ + css::util::XCloseable* m_pCloseable; + + ::osl::Condition m_aEndTryClosingCondition; + bool volatile m_bClosed; + bool volatile m_bInTryClose; + //the ownership between model and controller is not clear at first + //each controller might consider him as owner of the model first + //at start the model is not considered as owner of itself + bool volatile m_bOwnership; + +public: + CloseableLifeTimeManager( css::util::XCloseable* pCloseable + , css::lang::XComponent* pComponent ); + virtual ~CloseableLifeTimeManager() override; + + bool impl_isDisposedOrClosed( bool bAssert=true ); +/// @throws css::uno::Exception + bool g_close_startTryClose(bool bDeliverOwnership); +/// @throws css::util::CloseVetoException + void g_close_isNeedToCancelLongLastingCalls( bool bDeliverOwnership, css::util::CloseVetoException const & ex ); + void g_close_endTryClose(bool bDeliverOwnership ); + void g_close_endTryClose_doClose(); +/// @throws css::uno::RuntimeException + void g_addCloseListener( const css::uno::Reference< css::util::XCloseListener > & xListener ); + +private: + virtual bool impl_canStartApiCall() override; + virtual void impl_apiCallCountReachedNull() override; + + void impl_setOwnership( bool bDeliverOwnership, bool bMyVeto ); + void impl_doClose(); +}; + +/* +Use this Guard in your ApiCalls to protect access on resources +which will be released in dispose. +It's guaranteed that the release of resources only starts if your +guarded call has finished. +! It's only partly guaranteed that this resources will not change during the call. +See the example for details. + +This class is to be used as described in the example. + +If this guard is used in all api calls of an XCloseable object +it's guaranteed that the closeable will close itself after finishing the last call +if it should do so. + + ::ApiCall +{ + //hold no mutex!!! + LifeTimeGuard aLifeTimeGuard(m_aLifeTimeManager); + + //mutex is acquired; call is not registered + + if(!aLifeTimeGuard.startApiCall()) + return ; //behave as passive as possible, if disposed or closed + + //mutex is acquired, call is registered + { + //you might access some private members here + //but then you need to protect access to these members always like this + //never call to the outside here + } + + aLifeTimeGuard.clear(); //!!! + + //Mutex is released, the running call is still registered + //this call will finish before the 'release-section' in dispose is allowed to start + + { + //you might access some private members here guarded with your own mutex + //but release your mutex at the end of this block + } + + //you can call to the outside (without holding the mutex) without becoming disposed + + //End of method -> ~LifeTimeGuard + //-> call is unregistered + //-> this object might be disposed now +} + +your XComponent::dispose method has to be implemented in the following way: + + ::dispose() +{ + //hold no mutex!!! + if( !m_aLifeTimeManager.dispose() ) + return; + + //--release all resources and references + +} + +*/ + +class LifeTimeGuard +{ + +public: + LifeTimeGuard( LifeTimeManager& rManager ) + : m_guard( rManager.m_aAccessMutex ) + , m_rManager(rManager) + , m_bCallRegistered(false) + , m_bLongLastingCallRegistered(false) + { + + } + bool startApiCall(bool bLongLastingCall=false); + ~LifeTimeGuard(); + void clear() { m_guard.clear(); } + +private: + osl::ClearableMutexGuard m_guard; + LifeTimeManager& m_rManager; + bool m_bCallRegistered; + bool m_bLongLastingCallRegistered; + +private: + LifeTimeGuard( const LifeTimeGuard& ) = delete; + LifeTimeGuard& operator= ( const LifeTimeGuard& ) = delete; +}; + +template<class T> +class NegativeGuard final +{ + T * m_pT; +public: + + NegativeGuard(T & t) : m_pT(&t) + { + m_pT->release(); + } + + ~NegativeGuard() + { + m_pT->acquire(); + } +}; + +}//end namespace apphelper + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |