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 <cassert>
  27 #include <deque>
  28 #include <functional>
  29 #include <algorithm>
  30
  31 namespace comphelper
  32 {
  33     AnyEvent::AnyEvent()
  34     {
  35     }
  36
  37     AnyEvent::~AnyEvent()
  38     {
  39     }
  40
  41     struct ProcessableEvent
  42     {
  43         AnyEventRef                         aEvent;
  44         ::rtl::Reference< IEventProcessor > xProcessor;
  45
  46         ProcessableEvent()
  47         {
  48         }
  49
  50         ProcessableEvent( const AnyEventRef& _rEvent, const ::rtl::Reference< IEventProcessor >& _xProcessor )
  51             :aEvent( _rEvent )
  52             ,xProcessor( _xProcessor )
  53         {
  54         }
  55     };
  56
  57
  58     typedef ::std::deque< ProcessableEvent >    EventQueue;
  59
  60
  61     struct EqualProcessor : public ::std::unary_function< ProcessableEvent, bool >
  62     {
  63         const ::rtl::Reference< IEventProcessor >&  rProcessor;
  64         EqualProcessor( const ::rtl::Reference< IEventProcessor >& _rProcessor ) :rProcessor( _rProcessor ) { }
  65
  66         bool operator()( const ProcessableEvent& _rEvent )
  67         {
  68             return _rEvent.xProcessor.get() == rProcessor.get();
  69         }
  70     };
  71
  72
  73     struct EventNotifierImpl
  74     {
  75         ::osl::Mutex        aMutex;
  76         ::osl::Condition    aPendingActions;
  77         EventQueue          aEvents;
  78         bool                bTerminate;
  79
  80         EventNotifierImpl()
  81             :bTerminate( false )
  82         {
  83         }
  84     };
  85
  86     AsyncEventNotifier::AsyncEventNotifier(char const * name):
  87         Thread(name), m_xImpl(new EventNotifierImpl)
  88     {
  89     }
  90
  91
  92     AsyncEventNotifier::~AsyncEventNotifier()
  93     {
  94     }
  95
  96
  97     void AsyncEventNotifier::removeEventsForProcessor( const ::rtl::Reference< IEventProcessor >& _xProcessor )
  98     {
  99         ::osl::MutexGuard aGuard( m_xImpl->aMutex );
 100
 101         // remove all events for this processor
 102         m_xImpl->aEvents.erase(::std::remove_if( m_xImpl->aEvents.begin(), m_xImpl->aEvents.end(), EqualProcessor( _xProcessor ) ), m_xImpl->aEvents.end());
 103     }
 104
 105
 106     void SAL_CALL AsyncEventNotifier::terminate()
 107     {
 108         ::osl::MutexGuard aGuard( m_xImpl->aMutex );
 109
 110         // remember the termination request
 111         m_xImpl->bTerminate = true;
 112
 113         // awake the thread
 114         m_xImpl->aPendingActions.set();
 115     }
 116
 117
 118     void AsyncEventNotifier::addEvent( const AnyEventRef& _rEvent, const ::rtl::Reference< IEventProcessor >& _xProcessor )
 119     {
 120         ::osl::MutexGuard aGuard( m_xImpl->aMutex );
 121
 122         OSL_TRACE( "AsyncEventNotifier(%p): adding %p", this, _rEvent.get() );
 123         // remember this event
 124         m_xImpl->aEvents.push_back( ProcessableEvent( _rEvent, _xProcessor ) );
 125
 126         // awake the thread
 127         m_xImpl->aPendingActions.set();
 128     }
 129
 130
 131     void AsyncEventNotifier::execute()
 132     {
 133         for (;;)
 134         {
 135             m_xImpl->aPendingActions.wait();
 136             ProcessableEvent aEvent;
 137             {
 138                 osl::MutexGuard aGuard(m_xImpl->aMutex);
 139                 if (m_xImpl->bTerminate)
 140                 {
 141                     break;
 142                 }
 143                 if (!m_xImpl->aEvents.empty())
 144                 {
 145                     aEvent = m_xImpl->aEvents.front();
 146                     m_xImpl->aEvents.pop_front();
 147                     OSL_TRACE(
 148                         "AsyncEventNotifier(%p): popping %p", this,
 149                         aEvent.aEvent.get());
 150                 }
 151                 if (m_xImpl->aEvents.empty())
 152                 {
 153                     m_xImpl->aPendingActions.reset();
 154                 }
 155             }
 156             if (aEvent.aEvent.is()) {
 157                 assert(aEvent.xProcessor.is());
 158                 aEvent.xProcessor->processEvent(*aEvent.aEvent);
 159             }
 160         }
 161     }
 162
 163 } // namespace comphelper
 164
 165
 166 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */