Branch data Line data Source code
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_LISTENERCONTAINER_HXX
20 : : #define INCLUDED_SLIDESHOW_LISTENERCONTAINER_HXX
21 : :
22 : : #include <osl/mutex.hxx>
23 : : #include <boost/utility.hpp>
24 : : #include <algorithm>
25 : : #include <vector>
26 : :
27 : : #include "listenercontainerimpl.hxx"
28 : :
29 : : namespace slideshow {
30 : : namespace internal {
31 : :
32 : : /** Container for objects that can be notified.
33 : :
34 : : This templatized container holds listener objects, than can get
35 : : notified (by calling certain methods on them).
36 : :
37 : : @tpl Listener
38 : : Type for the listener objects to be held
39 : :
40 : : @tpl ContainerT
41 : : Full type of the container to store the listener objects. Defaults
42 : : to std::vector<ListenerT>
43 : :
44 : : @tpl MaxDeceasedListenerUllage
45 : : Threshold, from which upwards the listener container gets
46 : : pruned. Avoids frequent copying of nearly empty containers.
47 : :
48 : : @attention internal class, not to be used. functionality is
49 : : incomplete, please use the Thread(Un)safeListenerContainer types
50 : : from below
51 : : */
52 : : template< typename ListenerT,
53 : : typename MutexHolderBaseT,
54 : : typename ContainerT=std::vector<ListenerT>,
55 : 0 : size_t MaxDeceasedListenerUllage=16 > class ListenerContainerBase : public MutexHolderBaseT
56 : : {
57 : : typedef typename MutexHolderBaseT::Guard Guard;
58 : : typedef typename MutexHolderBaseT::ClearableGuard ClearableGuard;
59 : :
60 : : public:
61 : : typedef ListenerT listener_type;
62 : : typedef ContainerT container_type;
63 : : typedef MutexHolderBaseT mutex_type;
64 : :
65 : : /** Check whether listener container is empty
66 : :
67 : : @return true, if currently no listeners registered. Note that
68 : : in a multi-threaded scenario, without external synchronisation
69 : : to this object, the return value might become wrong at any time.
70 : : */
71 : 0 : bool isEmpty() const
72 : : {
73 : 0 : Guard aGuard(*this);
74 : 0 : return maListeners.empty();
75 : : }
76 : :
77 : : /** Check whether given listener is already added
78 : :
79 : : @return true, if given listener is already added.
80 : : */
81 : 0 : bool isAdded( listener_type const& rListener ) const
82 : : {
83 : 0 : Guard aGuard(*this);
84 : :
85 : 0 : const typename container_type::const_iterator aEnd( maListeners.end() );
86 : 0 : if( std::find( maListeners.begin(),
87 : : aEnd,
88 : : rListener ) != aEnd )
89 : : {
90 : 0 : return true; // already added
91 : : }
92 : :
93 : 0 : return false;
94 : : }
95 : :
96 : : /** Add new listener
97 : :
98 : : @param rListener
99 : : Listener to add
100 : :
101 : : @return false, if the listener is already added, true
102 : : otherwise
103 : : */
104 : 0 : bool add( listener_type const& rListener )
105 : : {
106 : 0 : Guard aGuard(*this);
107 : :
108 : : // ensure uniqueness
109 : 0 : if( isAdded(rListener) )
110 : 0 : return false; // already added
111 : :
112 : 0 : maListeners.push_back( rListener );
113 : :
114 : 0 : ListenerOperations<ListenerT>::pruneListeners(
115 : : maListeners,
116 : : MaxDeceasedListenerUllage);
117 : :
118 : 0 : return true;
119 : : }
120 : :
121 : : /** Add new listener into sorted container
122 : :
123 : : The stored listeners are kept sorted (using this method
124 : : requires listener_type to have operator< defined on it). Make
125 : : sure to call addSorted() for <em>each</em> listener to add to
126 : : this container - sorting is performed under the assumption
127 : : that existing entries are already sorted.
128 : :
129 : : @param rListener
130 : : Listener to add
131 : :
132 : : @return false, if the listener is already added, true
133 : : otherwise
134 : : */
135 : 0 : bool addSorted( listener_type const& rListener )
136 : : {
137 : 0 : Guard aGuard(*this);
138 : :
139 : : // ensure uniqueness
140 : 0 : if( isAdded(rListener) )
141 : 0 : return false; // already added
142 : :
143 : 0 : maListeners.push_back( rListener );
144 : :
145 : : // a single entry does not need to be sorted
146 : 0 : if( maListeners.size() > 1 )
147 : : {
148 : 0 : std::inplace_merge(
149 : : maListeners.begin(),
150 : : boost::prior(maListeners.end()),
151 : : maListeners.end() );
152 : : }
153 : :
154 : 0 : ListenerOperations<ListenerT>::pruneListeners(
155 : : maListeners,
156 : : MaxDeceasedListenerUllage);
157 : :
158 : 0 : return true;
159 : : }
160 : :
161 : : /** Remove listener from container
162 : :
163 : : @param rListener
164 : : The listener to remove
165 : :
166 : : @return false, if listener not found in container, true
167 : : otherwise
168 : : */
169 : 0 : bool remove( listener_type const& rListener )
170 : : {
171 : 0 : Guard aGuard(*this);
172 : :
173 : 0 : const typename container_type::iterator aEnd( maListeners.end() );
174 : 0 : typename container_type::iterator aIter;
175 : 0 : if( (aIter=std::remove(maListeners.begin(),
176 : : aEnd,
177 : : rListener)) == aEnd )
178 : : {
179 : 0 : return false; // listener not found
180 : : }
181 : :
182 : 0 : maListeners.erase( aIter, aEnd );
183 : :
184 : 0 : return true;
185 : : }
186 : :
187 : : /// Removes all listeners in one go
188 : 0 : void clear()
189 : : {
190 : 0 : Guard aGuard(*this);
191 : :
192 : 0 : maListeners.clear();
193 : 0 : }
194 : :
195 : : /** Apply functor to one listener
196 : :
197 : : This method applies functor to one of the listeners. Starting
198 : : with the first entry of the container, the functor is called
199 : : with the listener entries, until it returns true.
200 : :
201 : : @param func
202 : : Given functor is called with listeners, until it returns true
203 : :
204 : : @return true, if functor was successfully applied to a
205 : : listener
206 : : */
207 : 0 : template< typename FuncT > bool apply( FuncT func ) const
208 : : {
209 : 0 : ClearableGuard aGuard(*this);
210 : :
211 : : // generate a local copy of all handlers, to make method
212 : : // reentrant and thread-safe.
213 : 0 : container_type const local( maListeners );
214 : 0 : aGuard.clear();
215 : :
216 : : const bool bRet(
217 : : ListenerOperations<ListenerT>::notifySingleListener(
218 : : local,
219 : 0 : func ));
220 : :
221 : : {
222 : 0 : Guard aGuard2(*this);
223 : 0 : ListenerOperations<ListenerT>::pruneListeners(
224 : : const_cast<container_type&>(maListeners),
225 : : MaxDeceasedListenerUllage);
226 : : }
227 : :
228 : 0 : return bRet;
229 : : }
230 : :
231 : : /** Apply functor to all listeners
232 : :
233 : : This method applies functor to all of the listeners. Starting
234 : : with the first entry of the container, the functor is called
235 : : with the listener entries.
236 : :
237 : : @param func
238 : : Given functor is called with listeners.
239 : :
240 : : @return true, if functor was successfully applied to at least
241 : : one listener
242 : : */
243 : 0 : template< typename FuncT > bool applyAll( FuncT func ) const
244 : : {
245 : 0 : ClearableGuard aGuard(*this);
246 : :
247 : : // generate a local copy of all handlers, to make method
248 : : // reentrant and thread-safe.
249 : 0 : container_type const local( maListeners );
250 : 0 : aGuard.clear();
251 : :
252 : : const bool bRet(
253 : : ListenerOperations<ListenerT>::notifyAllListeners(
254 : : local,
255 : 0 : func ));
256 : :
257 : : {
258 : 0 : Guard aGuard2(*this);
259 : 0 : ListenerOperations<ListenerT>::pruneListeners(
260 : : const_cast<container_type&>(maListeners),
261 : : MaxDeceasedListenerUllage);
262 : : }
263 : :
264 : 0 : return bRet;
265 : : }
266 : :
267 : : private:
268 : : ContainerT maListeners;
269 : : };
270 : :
271 : : ////////////////////////////////////////////////////////////////////////////
272 : :
273 : : /** ListenerContainer variant that serialized access
274 : :
275 : : This ListenerContainer is safe to use in a multi-threaded
276 : : context. It serializes access to the object, and avoids
277 : : dead-locking by releasing the object mutex before calling
278 : : listeners.
279 : : */
280 : : template< typename ListenerT,
281 : : typename ContainerT=std::vector<ListenerT> >
282 : : class ThreadSafeListenerContainer : public ListenerContainerBase<ListenerT,
283 : : MutexBase,
284 : : ContainerT>
285 : : {
286 : : };
287 : :
288 : : ////////////////////////////////////////////////////////////////////////////
289 : :
290 : : /** ListenerContainer variant that does not serialize access
291 : :
292 : : This ListenerContainer version is not safe to use in a
293 : : multi-threaded scenario, but has less overhead.
294 : : */
295 : : template< typename ListenerT,
296 : : typename ContainerT=std::vector<ListenerT> >
297 : 0 : class ThreadUnsafeListenerContainer : public ListenerContainerBase<ListenerT,
298 : : EmptyBase,
299 : : ContainerT>
300 : : {
301 : : };
302 : :
303 : : } // namespace internal
304 : : } // namespace slideshow
305 : :
306 : : #endif /* INCLUDED_SLIDESHOW_LISTENERCONTAINER_HXX */
307 : :
308 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
