LibreOffice Module cppuhelper (master)  1
interfacecontainer.h
Go to the documentation of this file.
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_CPPUHELPER_INTERFACECONTAINER_H
20 #define INCLUDED_CPPUHELPER_INTERFACECONTAINER_H
21 
22 #include "sal/config.h"
23 
24 #include <cstddef>
25 #include <functional>
26 #include <vector>
27 #include <utility>
28 
29 #include "osl/diagnose.h"
30 #include "osl/mutex.hxx"
31 #include "rtl/alloc.h"
32 #include "com/sun/star/uno/Sequence.hxx"
33 #include "com/sun/star/lang/EventObject.hpp"
34 
35 #include "com/sun/star/lang/DisposedException.hpp"
37 
38 namespace com { namespace sun { namespace star { namespace uno { class XInterface; } } } }
39  //for docpp
41 namespace cppu
42 {
43 
44 namespace detail {
45 
51  {
52  std::vector< css::uno::Reference< css::uno::XInterface > > *pAsVector;
53  css::uno::XInterface * pAsInterface;
54  element_alias() : pAsInterface(NULL) {}
55  };
56 
57 }
58 
59 
60 class OInterfaceContainerHelper;
69 {
70 public:
85 
90 
92  bool SAL_CALL hasMoreElements() const
93  { return nRemain != 0; }
98  css::uno::XInterface * SAL_CALL next();
99 
105  void SAL_CALL remove();
106 
107 private:
110 
112 
113  sal_Int32 nRemain;
114 
116  SAL_DELETED_FUNCTION;
117  OInterfaceIteratorHelper & operator = ( const OInterfaceIteratorHelper & )
118  SAL_DELETED_FUNCTION;
119 };
120 
121 
129 {
130 public:
131  // these are here to force memory de/allocation to sal lib.
132  static void * SAL_CALL operator new( size_t nSize )
133  { return ::rtl_allocateMemory( nSize ); }
134  static void SAL_CALL operator delete( void * pMem )
135  { ::rtl_freeMemory( pMem ); }
136  static void * SAL_CALL operator new( size_t, void * pMem )
137  { return pMem; }
138  static void SAL_CALL operator delete( void *, void * )
139  {}
140 
148  OInterfaceContainerHelper( ::osl::Mutex & rMutex );
153  ~OInterfaceContainerHelper();
158  sal_Int32 SAL_CALL getLength() const;
159 
163  css::uno::Sequence< css::uno::Reference< css::uno::XInterface > > SAL_CALL getElements() const;
164 
181  sal_Int32 SAL_CALL addInterface( const css::uno::Reference< css::uno::XInterface > & rxIFace );
189  sal_Int32 SAL_CALL removeInterface( const css::uno::Reference< css::uno::XInterface > & rxIFace );
194  void SAL_CALL disposeAndClear( const css::lang::EventObject & rEvt );
198  void SAL_CALL clear();
199 
211  template <typename ListenerT, typename FuncT>
212  inline void forEach( FuncT const& func );
213 
235  template< typename ListenerT, typename EventT >
236  inline void notifyEach( void ( SAL_CALL ListenerT::*NotificationMethod )( const EventT& ), const EventT& Event );
237 
238 private:
245  ::osl::Mutex & rMutex;
250 
251  OInterfaceContainerHelper( const OInterfaceContainerHelper & )
252  SAL_DELETED_FUNCTION;
253  OInterfaceContainerHelper & operator = ( const OInterfaceContainerHelper & )
254  SAL_DELETED_FUNCTION;
255 
256  /*
257  Duplicate content of the container and release the old one without destroying.
258  The mutex must be locked and the memberbInUse must be true.
259  */
260  void copyAndResetInUse();
261 
262 private:
263  template< typename ListenerT, typename EventT >
265  {
266  private:
267  typedef void ( SAL_CALL ListenerT::*NotificationMethod )( const EventT& );
268  NotificationMethod m_pMethod;
269  const EventT& m_rEvent;
270  public:
271  NotifySingleListener( NotificationMethod method, const EventT& event ) : m_pMethod( method ), m_rEvent( event ) { }
272 
273  void operator()( const css::uno::Reference<ListenerT>& listener ) const
274  {
275  (listener.get()->*m_pMethod)( m_rEvent );
276  }
277  };
278 };
279 
280 template <typename ListenerT, typename FuncT>
281 inline void OInterfaceContainerHelper::forEach( FuncT const& func )
282 {
283  OInterfaceIteratorHelper iter( *this );
284  while (iter.hasMoreElements()) {
285  css::uno::Reference<ListenerT> const xListener( iter.next(), css::uno::UNO_QUERY );
286  if (xListener.is()) {
287  try {
288  func( xListener );
289  }
290  catch (css::lang::DisposedException const& exc) {
291  if (exc.Context == xListener)
292  iter.remove();
293  }
294  }
295  }
296 }
297 
298 template< typename ListenerT, typename EventT >
299 inline void OInterfaceContainerHelper::notifyEach( void ( SAL_CALL ListenerT::*NotificationMethod )( const EventT& ), const EventT& Event )
300 {
301  forEach< ListenerT, NotifySingleListener< ListenerT, EventT > >( NotifySingleListener< ListenerT, EventT >( NotificationMethod, Event ) );
302 }
303 
304 
311 template< class key, class hashImpl = void, class equalImpl = std::equal_to<key> >
313 {
314 public:
315  // these are here to force memory de/allocation to sal lib.
316  static void * SAL_CALL operator new( size_t nSize )
317  { return ::rtl_allocateMemory( nSize ); }
318  static void SAL_CALL operator delete( void * pMem )
319  { ::rtl_freeMemory( pMem ); }
320  static void * SAL_CALL operator new( size_t, void * pMem )
321  { return pMem; }
322  static void SAL_CALL operator delete( void *, void * )
323  {}
324 
332  inline OMultiTypeInterfaceContainerHelperVar( ::osl::Mutex & rMutex );
337 
341  inline css::uno::Sequence< key > SAL_CALL getContainedTypes() const;
342 
349  inline OInterfaceContainerHelper * SAL_CALL getContainer( const key & ) const;
350 
369  inline sal_Int32 SAL_CALL addInterface(
370  const key & rKey,
371  const css::uno::Reference< css::uno::XInterface > & r );
372 
383  inline sal_Int32 SAL_CALL removeInterface(
384  const key & rKey,
385  const css::uno::Reference< css::uno::XInterface > & rxIFace );
386 
392  inline void SAL_CALL disposeAndClear( const css::lang::EventObject & rEvt );
396  inline void SAL_CALL clear();
397 
398  typedef key keyType;
399 private:
400  typedef ::std::vector< std::pair < key , void* > > InterfaceMap;
401  InterfaceMap *m_pMap;
402  ::osl::Mutex & rMutex;
403 
404  typename InterfaceMap::iterator find(const key &rKey) const
405  {
406  typename InterfaceMap::iterator iter = m_pMap->begin();
407  typename InterfaceMap::iterator end = m_pMap->end();
408 
409  while( iter != end )
410  {
411  equalImpl equal;
412  if( equal( iter->first, rKey ) )
413  break;
414  ++iter;
415  }
416  return iter;
417  }
418 
420  OMultiTypeInterfaceContainerHelperVar & operator = ( const OMultiTypeInterfaceContainerHelperVar & ) SAL_DELETED_FUNCTION;
421 };
422 
423 
424 
425 
435 template < class container , class keyType >
436 struct SAL_WARN_UNUSED OBroadcastHelperVar
437 {
439  ::osl::Mutex & rMutex;
441  container aLC;
446 
451  OBroadcastHelperVar( ::osl::Mutex & rMutex_ )
452  : rMutex( rMutex_ )
453  , aLC( rMutex_ )
454  , bDisposed( false )
455  , bInDispose( false )
456  {}
457 
462  const keyType &key,
463  const css::uno::Reference < css::uno::XInterface > &r )
464  {
465  ::osl::MutexGuard guard( rMutex );
466  OSL_ENSURE( !bInDispose, "do not add listeners in the dispose call" );
467  OSL_ENSURE( !bDisposed, "object is disposed" );
468  if( ! bInDispose && ! bDisposed )
469  aLC.addInterface( key , r );
470  }
471 
476  const keyType &key,
477  const css::uno::Reference < css::uno::XInterface > & r )
478  {
479  ::osl::MutexGuard guard( rMutex );
480  if( ! bInDispose && ! bDisposed )
481  aLC.removeInterface( key , r );
482  }
483 
490  OInterfaceContainerHelper * SAL_CALL getContainer( const keyType &key ) const
491  { return aLC.getContainer( key ); }
492 };
493 
494 /*------------------------------------------
495 *
496 * In general, the above templates are used with a Type as key.
497 * Therefore a default declaration is given ( OMultiTypeInterfaceContainerHelper and OBroadcastHelper )
498 *
499 *------------------------------------------*/
500 
501 // helper function call class
503 {
504  size_t operator()(const css::uno::Type & s) const
505  { return static_cast<size_t>(s.getTypeName().hashCode()); }
506 };
507 
508 
513 {
514 public:
515  // these are here to force memory de/allocation to sal lib.
516  static void * SAL_CALL operator new( size_t nSize )
517  { return ::rtl_allocateMemory( nSize ); }
518  static void SAL_CALL operator delete( void * pMem )
519  { ::rtl_freeMemory( pMem ); }
520  static void * SAL_CALL operator new( size_t, void * pMem )
521  { return pMem; }
522  static void SAL_CALL operator delete( void *, void * )
523  {}
524 
532  OMultiTypeInterfaceContainerHelper( ::osl::Mutex & rMutex );
537 
541  css::uno::Sequence< css::uno::Type > SAL_CALL getContainedTypes() const;
542 
548  OInterfaceContainerHelper * SAL_CALL getContainer( const css::uno::Type & rKey ) const;
549 
568  sal_Int32 SAL_CALL addInterface(
569  const css::uno::Type & rKey,
570  const css::uno::Reference< css::uno::XInterface > & r );
571 
582  sal_Int32 SAL_CALL removeInterface(
583  const css::uno::Type & rKey,
584  const css::uno::Reference< css::uno::XInterface > & rxIFace );
585 
590  void SAL_CALL disposeAndClear( const css::lang::EventObject & rEvt );
594  void SAL_CALL clear();
595 
596  typedef css::uno::Type keyType;
597 private:
598  void * m_pMap;
599  ::osl::Mutex & rMutex;
600 
602  OMultiTypeInterfaceContainerHelper & operator = ( const OMultiTypeInterfaceContainerHelper & ) SAL_DELETED_FUNCTION;
603 };
604 
605 typedef OBroadcastHelperVar< OMultiTypeInterfaceContainerHelper , OMultiTypeInterfaceContainerHelper::keyType > OBroadcastHelper;
606 
607 }
608 
609 #endif
610 
611 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
This is here to optimise space in the common case that there are zero or one listeners.
NotifySingleListener(NotificationMethod method, const EventT &event)
OInterfaceContainerHelper & rCont
sal_Bool bInUse
TRUE -> used by an iterator.
std::vector< css::uno::Reference< css::uno::XInterface > > * pAsVector
css::uno::XInterface *SAL_CALL next()
Return the next element of the iterator.
void operator()(const css::uno::Reference< ListenerT > &listener) const
::osl::Mutex & rMutex
The shared mutex.
container aLC
ListenerContainer class is thread safe.
return NULL
OInterfaceContainerHelper *SAL_CALL getContainer(const keyType &key) const
Return the container created under this key.
This is the iterator of an InterfaceContainerHelper.
css::uno::XInterface * pAsInterface
detail::element_alias aData
bIsList == TRUE -> aData.pAsSequence of type Sequence< XInterfaceSequence >, otherwise aData...
InterfaceMap::iterator find(const key &rKey) const
A helper class to store interface references of different types.
void addListener(const keyType &key, const css::uno::Reference< css::uno::XInterface > &r)
adds a listener threadsafe.
sal_Bool bDisposed
Dispose call ready.
void removeListener(const keyType &key, const css::uno::Reference< css::uno::XInterface > &r)
removes a listener threadsafe
size_t operator()(const css::uno::Type &s) const
unsigned char sal_Bool
This struct contains the standard variables of a broadcaster.
sal_Bool bIsList
TRUE -> aData.pAsSequence is of type Sequence< XInterfaceSequence >.
sal_Bool bInDispose
In dispose call.
enumrange< T >::Iterator end(enumrange< T >)
::std::vector< std::pair< key, void * > > InterfaceMap
bool equal(Pair const &p1, Pair const &p2)
A container of interfaces.
OBroadcastHelperVar(::osl::Mutex &rMutex_)
Initialize the structure.
double getLength(const B2DPolygon &rCandidate)
void forEach(FuncT const &func)
Executes a functor for each contained listener of specified type, e.g.
void notifyEach(void(SAL_CALL ListenerT::*NotificationMethod)(const EventT &), const EventT &Event)
Calls a UNO listener method for each contained listener.
#define CPPUHELPER_DLLPUBLIC
Specialized class for key type css::uno::Type, without explicit usage of STL symbols.
void SAL_CALL remove()
Removes the current element (the last one returned by next()) from the underlying container...
bool SAL_CALL hasMoreElements() const
Return true, if there are more elements in the iterator.