include/comphelper/unique_disposing_ptr.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
  10 #ifndef INCLUDED_COMPHELPER_UNIQUE_DISPOSING_PTR_HXX
  11 #define INCLUDED_COMPHELPER_UNIQUE_DISPOSING_PTR_HXX
  12
  13 #include <cppuhelper/implbase.hxx>
  14
  15 #include <com/sun/star/lang/XComponent.hpp>
  16 #include <com/sun/star/frame/XDesktop.hpp>
  17 #include <com/sun/star/lang/XServiceInfo.hpp>
  18
  19 #include <vcl/svapp.hxx>
  20 #include <osl/mutex.hxx>
  21
  22 namespace comphelper
  23 {
  24 //Similar to std::unique_ptr, except additionally releases the ptr on XComponent::disposing and/or XTerminateListener::notifyTermination if supported
  25 template<class T> class unique_disposing_ptr
  26 {
  27 private:
  28     std::unique_ptr<T> m_xItem;
  29     css::uno::Reference< css::frame::XTerminateListener> m_xTerminateListener;
  30
  31     unique_disposing_ptr(const unique_disposing_ptr&) = delete;
  32     unique_disposing_ptr& operator=(const unique_disposing_ptr&) = delete;
  33 public:
  34     unique_disposing_ptr( const css::uno::Reference< css::lang::XComponent > &rComponent, T * p = nullptr, bool bComponent = false)
  35         : m_xItem(p)
  36     {
  37         m_xTerminateListener = new TerminateListener(rComponent, *this, bComponent);
  38     }
  39
  40     virtual void reset(T * p = nullptr)
  41     {
  42         m_xItem.reset(p);
  43     }
  44
  45     T & operator*() const
  46     {
  47         return *m_xItem;
  48     }
  49
  50     T * get() const
  51     {
  52         return m_xItem.get();
  53     }
  54
  55     T * operator->() const
  56     {
  57         return m_xItem.get();
  58     }
  59
  60     operator bool () const
  61     {
  62         return static_cast< bool >(m_xItem);
  63     }
  64
  65     virtual ~unique_disposing_ptr()
  66     {
  67         reset();
  68     }
  69 private:
  70     class TerminateListener : public ::cppu::WeakImplHelper< css::frame::XTerminateListener,
  71                                             css::lang::XServiceInfo>
  72     {
  73     private:
  74         css::uno::Reference< css::lang::XComponent > m_xComponent;
  75         unique_disposing_ptr<T>& m_rItem;
  76         bool mbComponentDLL;
  77     public:
  78         TerminateListener(const css::uno::Reference< css::lang::XComponent > &rComponent,
  79             unique_disposing_ptr<T>& rItem, bool bComponentDLL) :
  80                     m_xComponent(rComponent),
  81                     m_rItem(rItem),
  82                     mbComponentDLL(bComponentDLL)
  83         {
  84             if (m_xComponent.is())
  85             {
  86                 css::uno::Reference< css::frame::XDesktop> xDesktop(m_xComponent, css::uno::UNO_QUERY);
  87                 if (xDesktop.is())
  88                     xDesktop->addTerminateListener(this);
  89                 else
  90                     m_xComponent->addEventListener(this);
  91             }
  92         }
  93
  94         virtual ~TerminateListener() override
  95         {
  96             if ( m_xComponent.is() )
  97             {
  98                 css::uno::Reference< css::frame::XDesktop> xDesktop(m_xComponent, css::uno::UNO_QUERY);
  99                 if (xDesktop.is())
 100                     xDesktop->removeTerminateListener(this);
 101                 else
 102                     m_xComponent->removeEventListener(this);
 103             }
 104         }
 105
 106         // XEventListener
 107         virtual void SAL_CALL disposing( const css::lang::EventObject& rEvt )
 108             throw (css::uno::RuntimeException, std::exception) override
 109         {
 110             bool shutDown = (rEvt.Source == m_xComponent);
 111
 112             if (shutDown && m_xComponent.is())
 113             {
 114                 css::uno::Reference< css::frame::XDesktop> xDesktop(m_xComponent, css::uno::UNO_QUERY);
 115                 if (xDesktop.is())
 116                     xDesktop->removeTerminateListener(this);
 117                 else
 118                     m_xComponent->removeEventListener(this);
 119                 m_xComponent.clear();
 120             }
 121
 122             if (shutDown)
 123                m_rItem.reset();
 124         }
 125
 126         // XTerminateListener
 127         virtual void SAL_CALL queryTermination( const css::lang::EventObject& )
 128             throw(css::frame::TerminationVetoException,
 129                   css::uno::RuntimeException, std::exception) override
 130         {
 131         }
 132
 133         virtual void SAL_CALL notifyTermination( const css::lang::EventObject& rEvt )
 134             throw (css::uno::RuntimeException, std::exception) override
 135         {
 136             disposing(rEvt);
 137         }
 138
 139         virtual OUString SAL_CALL getImplementationName()
 140             throw (css::uno::RuntimeException, std::exception) override
 141         {
 142             if (mbComponentDLL)
 143                 return OUString("com.sun.star.comp.ComponentDLLListener");
 144             else
 145                 return OUString("com.sun.star.comp.DisposingTerminateListener");
 146         }
 147
 148         virtual sal_Bool SAL_CALL supportsService(const OUString& /*rName*/)
 149             throw (css::uno::RuntimeException, std::exception) override
 150         {
 151             return false;
 152         }
 153
 154         virtual css::uno::Sequence<OUString> SAL_CALL getSupportedServiceNames()
 155             throw (css::uno::RuntimeException, std::exception) override
 156         {
 157             return css::uno::Sequence<OUString>();
 158         }
 159    };
 160 };
 161
 162 //Something like an OutputDevice requires the SolarMutex to be taken before use
 163 //for threadsafety. The user can ensure this, except in the case of its dtor
 164 //being called from reset due to a terminate on the XComponent being called
 165 //from an arbitrary thread
 166 template<class T> class unique_disposing_solar_mutex_reset_ptr
 167     : public unique_disposing_ptr<T>
 168 {
 169 public:
 170     unique_disposing_solar_mutex_reset_ptr( const css::uno::Reference< css::lang::XComponent > &rComponent, T * p = nullptr, bool bComponent = false)
 171         : unique_disposing_ptr<T>(rComponent, p, bComponent)
 172     {
 173     }
 174
 175     virtual void reset(T * p = nullptr) override
 176     {
 177         SolarMutexGuard aGuard;
 178         unique_disposing_ptr<T>::reset(p);
 179     }
 180 };
 181
 182 }
 183
 184 #endif
 185
 186 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */