slideshow/source/inc/listenercontainer.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_SLIDESHOW_SOURCE_INC_LISTENERCONTAINER_HXX
  20 #define INCLUDED_SLIDESHOW_SOURCE_INC_LISTENERCONTAINER_HXX
  21
  22 #include <osl/mutex.hxx>
  23 #include <algorithm>
  24 #include <vector>
  25 #include <iterator>
  26
  27 namespace slideshow {
  28 namespace internal {
  29
  30 struct EmptyBase
  31 {
  32     struct EmptyGuard{ explicit EmptyGuard(EmptyBase) {} };
  33     struct EmptyClearableGuard
  34     {
  35         explicit EmptyClearableGuard(EmptyBase) {}
  36         static void clear() {}
  37     };
  38
  39     typedef EmptyGuard           Guard;
  40     typedef EmptyClearableGuard ClearableGuard;
  41 };
  42
  43 template< typename result_type, typename ListenerTargetT > struct FunctionApply
  44 {
  45     template<typename FuncT> static bool apply(
  46         FuncT           func,
  47         ListenerTargetT const& rArg )
  48     {
  49         return func(rArg);
  50     }
  51 };
  52
  53 template<typename ListenerTargetT> struct FunctionApply<void,ListenerTargetT>
  54 {
  55     template<typename FuncT> static bool apply(
  56         FuncT                  func,
  57         ListenerTargetT const& rArg )
  58     {
  59         func(rArg);
  60         return true;
  61     }
  62 };
  63
  64 template< typename ListenerT > struct ListenerOperations
  65 {
  66     /// Notify a single one of the listeners
  67     template< typename ContainerT,
  68               typename FuncT >
  69     static bool notifySingleListener( ContainerT& rContainer,
  70                                       FuncT       func )
  71     {
  72         // true: a handler in this queue processed the event
  73         // false: no handler in this queue finally processed the event
  74         return std::any_of( rContainer.begin(),
  75                             rContainer.end(),
  76                             func );
  77     }
  78
  79     /// Notify all listeners
  80     template< typename ContainerT,
  81               typename FuncT >
  82     static bool notifyAllListeners( ContainerT& rContainer,
  83                                     FuncT       func )
  84     {
  85         bool bRet(false);
  86         for( const auto& rCurr : rContainer )
  87         {
  88             if( FunctionApply< typename ::std::result_of< FuncT( const typename ContainerT::value_type& ) >::type,
  89                                typename ContainerT::value_type >::apply(
  90                                    func,
  91                                    rCurr) )
  92             {
  93                 bRet = true;
  94             }
  95         }
  96
  97         // true: at least one handler returned true
  98         // false: not a single handler returned true
  99         return bRet;
 100     }
 101
 102     /// Prune container from deceased listeners
 103     template< typename ContainerT >
 104     static void pruneListeners( ContainerT&, size_t )
 105     {
 106     }
 107 };
 108
 109 template< typename ListenerTargetT >
 110 struct ListenerOperations< std::weak_ptr<ListenerTargetT> >
 111 {
 112     template< typename ContainerT,
 113               typename FuncT >
 114     static bool notifySingleListener( ContainerT& rContainer,
 115                                       FuncT       func )
 116     {
 117         for( const auto& rCurr : rContainer )
 118         {
 119             std::shared_ptr<ListenerTargetT> pListener( rCurr.lock() );
 120
 121             if( pListener && func(pListener) )
 122                 return true;
 123         }
 124
 125         return false;
 126     }
 127
 128     template< typename ContainerT,
 129               typename FuncT >
 130     static bool notifyAllListeners( ContainerT& rContainer,
 131                                     FuncT       func )
 132     {
 133         bool bRet(false);
 134         for( const auto& rCurr : rContainer )
 135         {
 136             std::shared_ptr<ListenerTargetT> pListener( rCurr.lock() );
 137
 138             if( pListener.get() &&
 139                 FunctionApply<typename ::std::result_of<FuncT (std::shared_ptr<ListenerTargetT> const&)>::type,
 140                                std::shared_ptr<ListenerTargetT> >::apply(func,pListener) )
 141             {
 142                 bRet = true;
 143             }
 144         }
 145
 146         return bRet;
 147     }
 148     template< typename ContainerT >
 149     static void pruneListeners( ContainerT& rContainer,
 150                                 size_t      nSizeThreshold )
 151     {
 152         if( rContainer.size() <= nSizeThreshold )
 153             return;
 154
 155         ContainerT aAliveListeners;
 156         aAliveListeners.reserve(rContainer.size());
 157
 158         for( const auto& rCurr : rContainer )
 159         {
 160             if( !rCurr.expired() )
 161                 aAliveListeners.push_back( rCurr );
 162         }
 163
 164         std::swap( rContainer, aAliveListeners );
 165     }
 166 };
 167
 168 /** Container for objects that can be notified.
 169
 170     This templatized container holds listener objects, than can get
 171     notified (by calling certain methods on them).
 172
 173     @tpl Listener
 174     Type for the listener objects to be held
 175
 176     @tpl ContainerT
 177     Full type of the container to store the listener objects. Defaults
 178     to std::vector<ListenerT>
 179
 180     @tpl MaxDeceasedListenerUllage
 181     Threshold, from which upwards the listener container gets
 182     pruned. Avoids frequent copying of nearly empty containers.
 183
 184     @attention internal class, not to be used. functionality is
 185     incomplete, please use the Thread(Un)safeListenerContainer types
 186     from below
 187 */
 188 template< typename ListenerT,
 189           typename MutexHolderBaseT,
 190           typename ContainerT=std::vector<ListenerT>,
 191           size_t MaxDeceasedListenerUllage=16 > class ListenerContainerBase : public MutexHolderBaseT
 192 {
 193     typedef typename MutexHolderBaseT::Guard           Guard;
 194     typedef typename MutexHolderBaseT::ClearableGuard  ClearableGuard;
 195
 196 public:
 197     typedef ListenerT        listener_type;
 198     typedef ContainerT       container_type;
 199     typedef MutexHolderBaseT mutex_type;
 200
 201     /** Check whether listener container is empty
 202
 203         @return true, if currently no listeners registered. Note that
 204         in a multi-threaded scenario, without external synchronisation
 205         to this object, the return value might become wrong at any time.
 206      */
 207     bool isEmpty() const
 208     {
 209         Guard aGuard(*this);
 210         return maListeners.empty();
 211     }
 212
 213     /** Check whether given listener is already added
 214
 215         @return true, if given listener is already added.
 216      */
 217     bool isAdded( listener_type const& rListener ) const
 218     {
 219         Guard aGuard(*this);
 220
 221         const typename container_type::const_iterator aEnd( maListeners.end() );
 222         if( std::find( maListeners.begin(),
 223                        aEnd,
 224                        rListener ) != aEnd )
 225         {
 226             return true; // already added
 227         }
 228
 229         return false;
 230     }
 231
 232     /** Add new listener
 233
 234         @param rListener
 235         Listener to add
 236      */
 237     void add( listener_type const& rListener )
 238     {
 239         Guard aGuard(*this);
 240
 241         // ensure uniqueness
 242         if( isAdded(rListener) )
 243             return; // already added
 244
 245         maListeners.push_back( rListener );
 246
 247         ListenerOperations<ListenerT>::pruneListeners(
 248             maListeners,
 249             MaxDeceasedListenerUllage);
 250     }
 251
 252     /** Add new listener into sorted container
 253
 254         The stored listeners are kept sorted (using this method
 255         requires listener_type to have operator< defined on it). Make
 256         sure to call addSorted() for <em>each</em> listener to add to
 257         this container - sorting is performed under the assumption
 258         that existing entries are already sorted.
 259
 260         @param rListener
 261         Listener to add
 262
 263         @return false, if the listener is already added, true
 264         otherwise
 265      */
 266     bool addSorted( listener_type const& rListener )
 267     {
 268         Guard aGuard(*this);
 269
 270         // ensure uniqueness
 271         if( isAdded(rListener) )
 272             return false; // already added
 273
 274         maListeners.push_back( rListener );
 275
 276         // a single entry does not need to be sorted
 277         if( maListeners.size() > 1 )
 278         {
 279             std::inplace_merge(
 280                 maListeners.begin(),
 281                 std::prev(maListeners.end()),
 282                 maListeners.end() );
 283         }
 284
 285         ListenerOperations<ListenerT>::pruneListeners(
 286             maListeners,
 287             MaxDeceasedListenerUllage);
 288
 289         return true;
 290     }
 291
 292     /** Remove listener from container
 293
 294         @param rListener
 295         The listener to remove
 296
 297         @return false, if listener not found in container, true
 298         otherwise
 299      */
 300     bool remove( listener_type const& rListener )
 301     {
 302         Guard aGuard(*this);
 303
 304         const typename container_type::iterator aEnd( maListeners.end() );
 305         typename container_type::iterator       aIter;
 306         if( (aIter=std::remove(maListeners.begin(),
 307                                aEnd,
 308                                rListener)) == aEnd )
 309         {
 310             return false; // listener not found
 311         }
 312
 313         maListeners.erase( aIter, aEnd );
 314
 315         return true;
 316     }
 317
 318     /// Removes all listeners in one go
 319     void clear()
 320     {
 321         Guard aGuard(*this);
 322
 323         maListeners.clear();
 324     }
 325
 326     /** Apply functor to one listener
 327
 328         This method applies functor to one of the listeners. Starting
 329         with the first entry of the container, the functor is called
 330         with the listener entries, until it returns true.
 331
 332         @param func
 333         Given functor is called with listeners, until it returns true
 334
 335         @return true, if functor was successfully applied to a
 336         listener
 337      */
 338     template< typename FuncT > bool apply( FuncT func ) const
 339     {
 340         ClearableGuard aGuard(*this);
 341
 342         // generate a local copy of all handlers, to make method
 343         // reentrant and thread-safe.
 344         container_type const local( maListeners );
 345         aGuard.clear();
 346
 347         const bool bRet(
 348             ListenerOperations<ListenerT>::notifySingleListener(
 349                 local,
 350                 func ));
 351
 352         {
 353             Guard aGuard2(*this);
 354             ListenerOperations<ListenerT>::pruneListeners(
 355                 const_cast<container_type&>(maListeners),
 356                 MaxDeceasedListenerUllage);
 357         }
 358
 359         return bRet;
 360     }
 361
 362     /** Apply functor to all listeners
 363
 364         This method applies functor to all of the listeners. Starting
 365         with the first entry of the container, the functor is called
 366         with the listener entries.
 367
 368         @param func
 369         Given functor is called with listeners.
 370
 371         @return true, if functor was successfully applied to at least
 372         one listener
 373      */
 374     template< typename FuncT > bool applyAll( FuncT func ) const
 375     {
 376         ClearableGuard aGuard(*this);
 377
 378         // generate a local copy of all handlers, to make method
 379         // reentrant and thread-safe.
 380         container_type const local( maListeners );
 381         aGuard.clear();
 382
 383         const bool bRet(
 384             ListenerOperations<ListenerT>::notifyAllListeners(
 385                 local,
 386                 func ));
 387
 388         {
 389             Guard aGuard2(*this);
 390             ListenerOperations<ListenerT>::pruneListeners(
 391                 const_cast<container_type&>(maListeners),
 392                 MaxDeceasedListenerUllage);
 393         }
 394
 395         return bRet;
 396     }
 397
 398 private:
 399     ContainerT  maListeners;
 400 };
 401
 402
 403 /** ListenerContainer variant that does not serialize access
 404
 405     This ListenerContainer version is not safe to use in a
 406     multi-threaded scenario, but has less overhead.
 407  */
 408 template< typename ListenerT,
 409           typename ContainerT=std::vector<ListenerT> >
 410 class ThreadUnsafeListenerContainer : public ListenerContainerBase<ListenerT,
 411                                                                    EmptyBase,
 412                                                                    ContainerT>
 413 {
 414 };
 415
 416 } // namespace internal
 417 } // namespace slideshow
 418
 419 #endif // INCLUDED_SLIDESHOW_SOURCE_INC_LISTENERCONTAINER_HXX
 420
 421 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */