comphelper/source/misc/asyncnotification.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 <comphelper/asyncnotification.hxx>
  21 #include <osl/diagnose.h>
  22 #include <osl/mutex.hxx>
  23 #include <osl/conditn.hxx>
  24 #include <comphelper/guarding.hxx>
  25
  26 #include <deque>
  27 #include <set>
  28 #include <functional>
  29 #include <algorithm>
  30
  31 //........................................................................
  32 namespace comphelper
  33 {
  34 //........................................................................
  35
  36     //====================================================================
  37     //= AnyEvent
  38     //====================================================================
  39     //--------------------------------------------------------------------
  40     AnyEvent::AnyEvent()
  41         :m_refCount( 0 )
  42     {
  43     }
  44
  45     //--------------------------------------------------------------------
  46     AnyEvent::~AnyEvent()
  47     {
  48     }
  49
  50     //--------------------------------------------------------------------
  51     oslInterlockedCount SAL_CALL AnyEvent::acquire()
  52     {
  53         return osl_atomic_increment( &m_refCount );
  54     }
  55
  56     //--------------------------------------------------------------------
  57     oslInterlockedCount SAL_CALL AnyEvent::release()
  58     {
  59         if ( 0 == osl_atomic_decrement( &m_refCount ) )
  60         {
  61             delete this;
  62             return 0;
  63         }
  64         return m_refCount;
  65     }
  66
  67     //====================================================================
  68     //= ProcessableEvent
  69     //====================================================================
  70     struct ProcessableEvent
  71     {
  72         AnyEventRef                         aEvent;
  73         ::rtl::Reference< IEventProcessor > xProcessor;
  74
  75         ProcessableEvent( const AnyEventRef& _rEvent, const ::rtl::Reference< IEventProcessor >& _xProcessor )
  76             :aEvent( _rEvent )
  77             ,xProcessor( _xProcessor )
  78         {
  79         }
  80
  81         ProcessableEvent( const ProcessableEvent& _rRHS )
  82             :aEvent( _rRHS.aEvent )
  83             ,xProcessor( _rRHS.xProcessor )
  84         {
  85         }
  86
  87         ProcessableEvent& operator=( const ProcessableEvent& _rRHS )
  88         {
  89             aEvent = _rRHS.aEvent;
  90             xProcessor = _rRHS.xProcessor;
  91             return *this;
  92         }
  93     };
  94
  95     //====================================================================
  96     typedef ::std::deque< ProcessableEvent >    EventQueue;
  97
  98     //====================================================================
  99     struct EqualProcessor : public ::std::unary_function< ProcessableEvent, bool >
 100     {
 101         const ::rtl::Reference< IEventProcessor >&  rProcessor;
 102         EqualProcessor( const ::rtl::Reference< IEventProcessor >& _rProcessor ) :rProcessor( _rProcessor ) { }
 103
 104         bool operator()( const ProcessableEvent& _rEvent )
 105         {
 106             return _rEvent.xProcessor.get() == rProcessor.get();
 107         }
 108     };
 109
 110     //====================================================================
 111     //= EventNotifierImpl
 112     //====================================================================
 113     struct EventNotifierImpl
 114     {
 115         ::osl::Mutex        aMutex;
 116         oslInterlockedCount m_refCount;
 117         ::osl::Condition    aPendingActions;
 118         EventQueue          aEvents;
 119         ::std::set< ::rtl::Reference< IEventProcessor > >
 120                             m_aDeadProcessors;
 121
 122         EventNotifierImpl()
 123             :m_refCount( 0 )
 124         {
 125         }
 126
 127     private:
 128         EventNotifierImpl( const EventNotifierImpl& );              // never implemented
 129         EventNotifierImpl& operator=( const EventNotifierImpl& );   // never implemented
 130     };
 131
 132     //====================================================================
 133     //= AsyncEventNotifier
 134     //====================================================================
 135     //--------------------------------------------------------------------
 136     AsyncEventNotifier::AsyncEventNotifier(char const * name):
 137         Thread(name), m_pImpl(new EventNotifierImpl)
 138     {
 139     }
 140
 141     //--------------------------------------------------------------------
 142     AsyncEventNotifier::~AsyncEventNotifier()
 143     {
 144     }
 145
 146     //--------------------------------------------------------------------
 147     void AsyncEventNotifier::removeEventsForProcessor( const ::rtl::Reference< IEventProcessor >& _xProcessor )
 148     {
 149         ::osl::MutexGuard aGuard( m_pImpl->aMutex );
 150
 151         // remove all events for this processor
 152         ::std::remove_if( m_pImpl->aEvents.begin(), m_pImpl->aEvents.end(), EqualProcessor( _xProcessor ) );
 153
 154         // and just in case that an event for exactly this processor has just been
 155         // popped from the queue, but not yet processed: remember it:
 156         m_pImpl->m_aDeadProcessors.insert( _xProcessor );
 157     }
 158
 159     //--------------------------------------------------------------------
 160     void SAL_CALL AsyncEventNotifier::terminate()
 161     {
 162         ::osl::MutexGuard aGuard( m_pImpl->aMutex );
 163
 164         // remember the termination request
 165         Thread::terminate();
 166
 167         // awake the thread
 168         m_pImpl->aPendingActions.set();
 169     }
 170
 171     //--------------------------------------------------------------------
 172     void AsyncEventNotifier::addEvent( const AnyEventRef& _rEvent, const ::rtl::Reference< IEventProcessor >& _xProcessor )
 173     {
 174         ::osl::MutexGuard aGuard( m_pImpl->aMutex );
 175
 176         OSL_TRACE( "AsyncEventNotifier(%p): adding %p", this, _rEvent.get() );
 177         // remember this event
 178         m_pImpl->aEvents.push_back( ProcessableEvent( _rEvent, _xProcessor ) );
 179
 180         // awake the thread
 181         m_pImpl->aPendingActions.set();
 182     }
 183
 184     //--------------------------------------------------------------------
 185     void AsyncEventNotifier::execute()
 186     {
 187         do
 188         {
 189             AnyEventRef aNextEvent;
 190             ::rtl::Reference< IEventProcessor > xNextProcessor;
 191
 192             ::osl::ClearableMutexGuard aGuard( m_pImpl->aMutex );
 193             while ( m_pImpl->aEvents.size() > 0 )
 194             {
 195                 ProcessableEvent aEvent( m_pImpl->aEvents.front() );
 196                 aNextEvent = aEvent.aEvent;
 197                 xNextProcessor = aEvent.xProcessor;
 198                 m_pImpl->aEvents.pop_front();
 199
 200                 OSL_TRACE( "AsyncEventNotifier(%p): popping %p", this, aNextEvent.get() );
 201
 202                 if ( !aNextEvent.get() )
 203                     continue;
 204
 205                 // process the event, but only if it's processor did not die inbetween
 206                 ::std::set< ::rtl::Reference< IEventProcessor > >::iterator deadPos = m_pImpl->m_aDeadProcessors.find( xNextProcessor );
 207                 if ( deadPos != m_pImpl->m_aDeadProcessors.end() )
 208                 {
 209                     m_pImpl->m_aDeadProcessors.erase( xNextProcessor );
 210                     xNextProcessor.clear();
 211                     OSL_TRACE( "AsyncEventNotifier(%p): removing %p", this, aNextEvent.get() );
 212                 }
 213
 214                 // if there was a termination request (->terminate), respect it
 215                 if ( !schedule() )
 216                     return;
 217
 218                 {
 219                     ::comphelper::MutexRelease aReleaseOnce( m_pImpl->aMutex );
 220                     if ( xNextProcessor.get() )
 221                         xNextProcessor->processEvent( *aNextEvent.get() );
 222                 }
 223             }
 224
 225             // if there was a termination request (->terminate), respect it
 226             if ( !schedule() )
 227                 return;
 228
 229             // wait for new events to process
 230             aGuard.clear();
 231             m_pImpl->aPendingActions.reset();
 232             m_pImpl->aPendingActions.wait();
 233         }
 234         while ( true );
 235     }
 236
 237 //........................................................................
 238 } // namespace comphelper
 239 //........................................................................
 240
 241 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */