chart2/source/inc/LifeTime.hxx

   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 #ifndef INCLUDED_CHART2_SOURCE_INC_LIFETIME_HXX
  20 #define INCLUDED_CHART2_SOURCE_INC_LIFETIME_HXX
  21
  22 #include <osl/mutex.hxx>
  23 #include <osl/conditn.hxx>
  24 #include <cppuhelper/interfacecontainer.h>
  25 #include "charttoolsdllapi.hxx"
  26
  27 namespace com { namespace sun { namespace star { namespace lang { class XComponent; } } } }
  28 namespace com { namespace sun { namespace star { namespace util { class CloseVetoException; } } } }
  29 namespace com { namespace sun { namespace star { namespace util { class XCloseListener; } } } }
  30 namespace com { namespace sun { namespace star { namespace util { class XCloseable; } } } }
  31
  32 namespace apphelper
  33 {
  34
  35 class OOO_DLLPUBLIC_CHARTTOOLS LifeTimeManager
  36 {
  37 friend class LifeTimeGuard;
  38 protected:
  39     mutable ::osl::Mutex                    m_aAccessMutex;
  40 public:
  41     LifeTimeManager( css::lang::XComponent* pComponent );
  42     virtual ~LifeTimeManager();
  43
  44     bool        impl_isDisposed( bool bAssert=true );
  45     /// @throws css::uno::RuntimeException
  46     bool    dispose();
  47
  48 public:
  49     ::cppu::OMultiTypeInterfaceContainerHelper      m_aListenerContainer;
  50
  51 protected:
  52     SAL_DLLPRIVATE virtual bool    impl_canStartApiCall();
  53     SAL_DLLPRIVATE virtual void        impl_apiCallCountReachedNull(){}
  54
  55     SAL_DLLPRIVATE void        impl_registerApiCall(bool bLongLastingCall);
  56     SAL_DLLPRIVATE void        impl_unregisterApiCall(bool bLongLastingCall);
  57
  58 protected:
  59     css::lang::XComponent*     m_pComponent;
  60
  61     ::osl::Condition        m_aNoAccessCountCondition;
  62     sal_Int32               m_nAccessCount;
  63
  64     bool volatile       m_bDisposed;
  65     bool volatile       m_bInDispose;
  66
  67     ::osl::Condition        m_aNoLongLastingCallCountCondition;
  68     sal_Int32               m_nLongLastingCallCount;
  69 };
  70
  71 class CloseableLifeTimeManager final : public LifeTimeManager
  72 {
  73     css::util::XCloseable*         m_pCloseable;
  74
  75     ::osl::Condition    m_aEndTryClosingCondition;
  76     bool volatile       m_bClosed;
  77     bool volatile       m_bInTryClose;
  78     //the ownership between model and controller is not clear at first
  79     //each controller might consider him as owner of the model first
  80     //at start the model is not considered as owner of itself
  81     bool volatile       m_bOwnership;
  82
  83 public:
  84 OOO_DLLPUBLIC_CHARTTOOLS    CloseableLifeTimeManager( css::util::XCloseable* pCloseable
  85         , css::lang::XComponent* pComponent );
  86 OOO_DLLPUBLIC_CHARTTOOLS    virtual ~CloseableLifeTimeManager() override;
  87
  88 OOO_DLLPUBLIC_CHARTTOOLS    bool    impl_isDisposedOrClosed( bool bAssert=true );
  89 /// @throws css::uno::Exception
  90 OOO_DLLPUBLIC_CHARTTOOLS    bool    g_close_startTryClose(bool bDeliverOwnership);
  91 /// @throws css::util::CloseVetoException
  92 OOO_DLLPUBLIC_CHARTTOOLS    void    g_close_isNeedToCancelLongLastingCalls( bool bDeliverOwnership, css::util::CloseVetoException const & ex );
  93 OOO_DLLPUBLIC_CHARTTOOLS    void    g_close_endTryClose(bool bDeliverOwnership );
  94 OOO_DLLPUBLIC_CHARTTOOLS    void    g_close_endTryClose_doClose();
  95 /// @throws css::uno::RuntimeException
  96 OOO_DLLPUBLIC_CHARTTOOLS    void    g_addCloseListener( const css::uno::Reference< css::util::XCloseListener > & xListener );
  97
  98 private:
  99     virtual bool    impl_canStartApiCall() override;
 100     virtual void    impl_apiCallCountReachedNull() override;
 101
 102     void        impl_setOwnership( bool bDeliverOwnership, bool bMyVeto );
 103     void        impl_doClose();
 104 };
 105
 106 /*
 107 Use this Guard in your ApiCalls to protect access on resources
 108 which will be released in dispose.
 109 It's guaranteed that the release of resources only starts if your
 110 guarded call has finished.
 111 ! It's only partly guaranteed that this resources will not change during the call.
 112 See the example for details.
 113
 114 This class is to be used as described in the example.
 115
 116 If this guard is used in all api calls of an XCloseable object
 117 it's guaranteed that the closeable will close itself after finishing the last call
 118 if it should do so.
 119
 120   ::ApiCall
 121 {
 122     //hold no mutex!!!
 123     LifeTimeGuard aLifeTimeGuard(m_aLifeTimeManager);
 124
 125     //mutex is acquired; call is not registered
 126
 127     if(!aLifeTimeGuard.startApiCall())
 128         return ; //behave as passive as possible, if disposed or closed
 129
 130     //mutex is acquired, call is registered
 131     {
 132         //you might access some private members here
 133         //but then you need to protect access to these members always like this
 134         //never call to the outside here
 135     }
 136
 137     aLifeTimeGuard.clear(); //!!!
 138
 139       //Mutex is released, the running call is still registered
 140     //this call will finish before the 'release-section' in dispose is allowed to start
 141
 142     {
 143         //you might access some private members here guarded with your own mutex
 144         //but release your mutex at the end of this block
 145     }
 146
 147     //you can call to the outside (without holding the mutex) without becoming disposed
 148
 149     //End of method -> ~LifeTimeGuard
 150     //-> call is unregistered
 151     //-> this object might be disposed now
 152 }
 153
 154 your XComponent::dispose method has to be implemented in the following way:
 155
 156     ::dispose()
 157 {
 158     //hold no mutex!!!
 159     if( !m_aLifeTimeManager.dispose() )
 160         return;
 161
 162     //--release all resources and references
 163
 164 }
 165
 166 */
 167
 168 class OOO_DLLPUBLIC_CHARTTOOLS LifeTimeGuard
 169 {
 170
 171 public:
 172     LifeTimeGuard( LifeTimeManager& rManager )
 173         : m_guard( rManager.m_aAccessMutex )
 174         , m_rManager(rManager)
 175         , m_bCallRegistered(false)
 176         , m_bLongLastingCallRegistered(false)
 177     {
 178
 179     }
 180     bool startApiCall(bool bLongLastingCall=false);
 181     ~LifeTimeGuard();
 182     void clear() { m_guard.clear(); }
 183
 184 private:
 185     osl::ClearableMutexGuard m_guard;
 186     LifeTimeManager&    m_rManager;
 187     bool            m_bCallRegistered;
 188     bool            m_bLongLastingCallRegistered;
 189
 190 private:
 191     LifeTimeGuard( const LifeTimeGuard& ) = delete;
 192     LifeTimeGuard& operator= ( const LifeTimeGuard& ) = delete;
 193 };
 194
 195 template<class T>
 196 class NegativeGuard final
 197 {
 198     T * m_pT;
 199 public:
 200
 201     NegativeGuard(T & t) : m_pT(&t)
 202     {
 203         m_pT->release();
 204     }
 205
 206     ~NegativeGuard()
 207     {
 208         m_pT->acquire();
 209     }
 210 };
 211
 212 }//end namespace apphelper
 213 #endif
 214
 215 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */