slideshow/source/inc/listenercontainerimpl.hxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: listenercontainerimpl.hxx,v $
  10  * $Revision: 1.3 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30 #ifndef INCLUDED_SLIDESHOW_LISTENERCONTAINERIMPL_HXX
  31 #define INCLUDED_SLIDESHOW_LISTENERCONTAINERIMPL_HXX
  32
  33 #include <sal/config.h>
  34 #include <boost/weak_ptr.hpp>
  35
  36 namespace slideshow {
  37 namespace internal {
  38
  39 ////////////////////////////////////////////////////////////////////////////
  40
  41 struct EmptyBase
  42 {
  43     struct EmptyGuard{ explicit EmptyGuard(EmptyBase) {} };
  44     struct EmptyClearableGuard
  45     {
  46         explicit EmptyClearableGuard(EmptyBase) {}
  47         void clear() {}
  48         void reset() {}
  49     };
  50
  51     typedef EmptyGuard           Guard;
  52     typedef EmptyClearableGuard ClearableGuard;
  53 };
  54
  55 class MutexBase
  56 {
  57 public:
  58     struct Guard : public osl::MutexGuard
  59     {
  60         explicit Guard(MutexBase const& rBase) :
  61             osl::MutexGuard(rBase.maMutex)
  62         {}
  63     };
  64     struct ClearableGuard : public osl::ClearableMutexGuard
  65     {
  66         explicit ClearableGuard(MutexBase const& rBase) :
  67             osl::ClearableMutexGuard(rBase.maMutex)
  68         {}
  69     };
  70
  71     mutable osl::Mutex maMutex;
  72 };
  73
  74 ////////////////////////////////////////////////////////////////////////////
  75
  76 template< typename result_type, typename ListenerTargetT > struct FunctionApply
  77 {
  78     template<typename FuncT> static bool apply(
  79         FuncT           func,
  80         ListenerTargetT const& rArg )
  81     {
  82         return func(rArg);
  83     }
  84 };
  85
  86 template<typename ListenerTargetT> struct FunctionApply<void,ListenerTargetT>
  87 {
  88     template<typename FuncT> static bool apply(
  89         FuncT                  func,
  90         ListenerTargetT const& rArg )
  91     {
  92         func(rArg);
  93         return true;
  94     }
  95 };
  96
  97 ////////////////////////////////////////////////////////////////////////////
  98
  99 template< typename ListenerT > struct ListenerOperations
 100 {
 101     /// Notify a single one of the listeners
 102     template< typename ContainerT,
 103               typename FuncT >
 104     static bool notifySingleListener( ContainerT& rContainer,
 105                                       FuncT       func )
 106     {
 107         const typename ContainerT::const_iterator aEnd( rContainer.end() );
 108
 109         // true: a handler in this queue processed the event
 110         // false: no handler in this queue finally processed the event
 111         return (std::find_if( rContainer.begin(),
 112                               aEnd,
 113                               func ) != aEnd);
 114     }
 115
 116     /// Notify all listeners
 117     template< typename ContainerT,
 118               typename FuncT >
 119     static bool notifyAllListeners( ContainerT& rContainer,
 120                                     FuncT       func )
 121     {
 122         bool bRet(false);
 123         typename ContainerT::const_iterator       aCurr( rContainer.begin() );
 124         typename ContainerT::const_iterator const aEnd ( rContainer.end() );
 125         while( aCurr != aEnd )
 126         {
 127             if( FunctionApply< typename FuncT::result_type,
 128                                typename ContainerT::value_type >::apply(
 129                                    func,
 130                                    *aCurr) )
 131             {
 132                 bRet = true;
 133             }
 134
 135             ++aCurr;
 136         }
 137
 138         // true: at least one handler returned true
 139         // false: not a single handler returned true
 140         return bRet;
 141     }
 142
 143     /// Prune container from deceased listeners
 144     template< typename ContainerT >
 145     static void pruneListeners( ContainerT&, size_t )
 146     {
 147     }
 148 };
 149
 150 // specializations for weak_ptr
 151 // ----------------------------
 152 template< typename ListenerTargetT >
 153 struct ListenerOperations< boost::weak_ptr<ListenerTargetT> >
 154 {
 155     template< typename ContainerT,
 156               typename FuncT >
 157     static bool notifySingleListener( ContainerT& rContainer,
 158                                       FuncT       func )
 159     {
 160         typename ContainerT::const_iterator       aCurr( rContainer.begin() );
 161         typename ContainerT::const_iterator const aEnd ( rContainer.end() );
 162         while( aCurr != aEnd )
 163         {
 164             boost::shared_ptr<ListenerTargetT> pListener( aCurr->lock() );
 165
 166             if( pListener && func(pListener) )
 167                 return true;
 168
 169             ++aCurr;
 170         }
 171
 172         return false;
 173     }
 174
 175     template< typename ContainerT,
 176               typename FuncT >
 177     static bool notifyAllListeners( ContainerT& rContainer,
 178                                     FuncT       func )
 179     {
 180         bool bRet(false);
 181         typename ContainerT::const_iterator       aCurr( rContainer.begin() );
 182         typename ContainerT::const_iterator const aEnd ( rContainer.end() );
 183         while( aCurr != aEnd )
 184         {
 185             boost::shared_ptr<ListenerTargetT> pListener( aCurr->lock() );
 186
 187             if( pListener.get() &&
 188                 FunctionApply< typename FuncT::result_type,
 189                                boost::shared_ptr<ListenerTargetT> >::apply(func,pListener) )
 190             {
 191                 bRet = true;
 192             }
 193
 194             ++aCurr;
 195         }
 196
 197         return bRet;
 198     }
 199
 200     template< typename ContainerT >
 201     static void pruneListeners( ContainerT& rContainer,
 202                                 size_t      nSizeThreshold )
 203     {
 204         if( rContainer.size() <= nSizeThreshold )
 205             return;
 206
 207         ContainerT aAliveListeners;
 208         aAliveListeners.reserve(rContainer.size());
 209
 210         typename ContainerT::const_iterator       aCurr( rContainer.begin() );
 211         typename ContainerT::const_iterator const aEnd ( rContainer.end() );
 212         while( aCurr != aEnd )
 213         {
 214             if( !aCurr->expired() )
 215                 aAliveListeners.push_back( *aCurr );
 216
 217             ++aCurr;
 218         }
 219
 220         std::swap( rContainer, aAliveListeners );
 221     }
 222 };
 223
 224 } // namespace internal
 225 } // namespace Presentation
 226
 227 #endif /* INCLUDED_SLIDESHOW_LISTENERCONTAINERIMPL_HXX */
 228