LibreOffice: cppuhelper/interfacecontainer.hxx Source File

LibreOffice LibreOffice 7.4 SDK C/C++ API Reference

Loading...
Searching...
No Matches
interfacecontainer.hxx
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
20/*
21 * This file is part of LibreOffice published API.
22 */
23#ifndef INCLUDED_CPPUHELPER_INTERFACECONTAINER_HXX
24#define INCLUDED_CPPUHELPER_INTERFACECONTAINER_HXX
25
26#include "sal/config.h"
27
28#include <cstddef>
29
30#include "cppuhelper/interfacecontainer.h"
31
32
33namespace cppu
34{
35
36template< class key , class hashImpl , class equalImpl >
37 inline OMultiTypeInterfaceContainerHelperVar< key , hashImpl , equalImpl >::OMultiTypeInterfaceContainerHelperVar( ::osl::Mutex & rMutex_ )
38 : rMutex( rMutex_ )
39{
40 m_pMap = new InterfaceMap;
41}
42
43
44template< class key , class hashImpl , class equalImpl >
45 inline OMultiTypeInterfaceContainerHelperVar< key , hashImpl , equalImpl >::~OMultiTypeInterfaceContainerHelperVar()
46{
47 typename InterfaceMap::iterator iter = m_pMap->begin();
48 typename InterfaceMap::iterator end = m_pMap->end();
49
50 while( iter != end )
51 {
52 delete static_cast<OInterfaceContainerHelper*>((*iter).second);
53 (*iter).second = NULL;
54 ++iter;
55 }
56 delete m_pMap;
57}
58
59
60template< class key , class hashImpl , class equalImpl >
61 inline css::uno::Sequence< key > OMultiTypeInterfaceContainerHelperVar< key , hashImpl , equalImpl >::getContainedTypes() const
62{
63 ::osl::MutexGuard aGuard( rMutex );
64 typename InterfaceMap::size_type nSize = m_pMap->size();
65 if( nSize != 0 )
66 {
67 css::uno::Sequence< key > aInterfaceTypes( nSize );
68 key * pArray = aInterfaceTypes.getArray();
69
70 typename InterfaceMap::iterator iter = m_pMap->begin();
71 typename InterfaceMap::iterator end = m_pMap->end();
72
73 sal_uInt32 i = 0;
74 while( iter != end )
75 {
76 // are interfaces added to this container?
77 if( static_cast<OInterfaceContainerHelper*>((*iter).second)->getLength() )
78 // yes, put the type in the array
79 pArray[i++] = (*iter).first;
80 ++iter;
81 }
82 if( i != nSize ) {
83 // may be empty container, reduce the sequence to the right size
84 aInterfaceTypes = css::uno::Sequence<key>( pArray, i );
85 }
86 return aInterfaceTypes;
87 }
88 return css::uno::Sequence<key>();
89}
90
91
92template< class key , class hashImpl , class equalImpl >
93 OInterfaceContainerHelper * OMultiTypeInterfaceContainerHelperVar< key , hashImpl , equalImpl >::getContainer(
94 const key & rKey ) const
95{
96 ::osl::MutexGuard aGuard( rMutex );
97
98 typename InterfaceMap::iterator iter = find( rKey );
99 if( iter != m_pMap->end() )
100 return static_cast<OInterfaceContainerHelper*>( (*iter).second );
101 return NULL;
102}
103
104
105template< class key , class hashImpl , class equalImpl >
106sal_Int32 OMultiTypeInterfaceContainerHelperVar< key , hashImpl , equalImpl >::addInterface(
107 const key & rKey,
108 const css::uno::Reference< css::uno::XInterface > & rListener )
109{
110 ::osl::MutexGuard aGuard( rMutex );
111 typename InterfaceMap::iterator iter = find( rKey );
112 if( iter == m_pMap->end() )
113 {
114 OInterfaceContainerHelper * pLC = new OInterfaceContainerHelper( rMutex );
115 m_pMap->push_back(std::pair<key, void*>(rKey, pLC));
116 return pLC->addInterface( rListener );
117 }
118 else
119 return static_cast<OInterfaceContainerHelper*>((*iter).second)->addInterface( rListener );
120}
121
122
123template< class key , class hashImpl , class equalImpl >
124 inline sal_Int32 OMultiTypeInterfaceContainerHelperVar< key , hashImpl , equalImpl >::removeInterface(
125 const key & rKey,
126 const css::uno::Reference< css::uno::XInterface > & rListener )
127{
128 ::osl::MutexGuard aGuard( rMutex );
129
130 // search container with id nUik
131 typename InterfaceMap::iterator iter = find( rKey );
132 // container found?
133 if( iter != m_pMap->end() )
134 return static_cast<OInterfaceContainerHelper*>((*iter).second)->removeInterface( rListener );
135
136 // no container with this id. Always return 0
137 return 0;
138}
139
140
141template< class key , class hashImpl , class equalImpl >
142 void OMultiTypeInterfaceContainerHelperVar< key , hashImpl , equalImpl >::disposeAndClear(
143 const css::lang::EventObject & rEvt )
144{
145 typename InterfaceMap::size_type nSize = 0;
146 OInterfaceContainerHelper ** ppListenerContainers = NULL;
147 {
148 ::osl::MutexGuard aGuard( rMutex );
149 nSize = m_pMap->size();
150 if( nSize )
151 {
152 typedef OInterfaceContainerHelper* ppp;
153 ppListenerContainers = new ppp[nSize];
154
155 typename InterfaceMap::iterator iter = m_pMap->begin();
156 typename InterfaceMap::iterator end = m_pMap->end();
157
158 typename InterfaceMap::size_type i = 0;
159 while( iter != end )
160 {
161 ppListenerContainers[i++] = static_cast<OInterfaceContainerHelper*>((*iter).second);
162 ++iter;
163 }
164 }
165 }
166
167 // create a copy, because do not fire event in a guarded section
168 for( typename InterfaceMap::size_type i = 0; i < nSize; i++ )
169 {
170 if( ppListenerContainers[i] )
171 ppListenerContainers[i]->disposeAndClear( rEvt );
172 }
173
174 delete [] ppListenerContainers;
175}
176
177
178template< class key , class hashImpl , class equalImpl >
179 void OMultiTypeInterfaceContainerHelperVar< key , hashImpl , equalImpl >::clear()
180{
181 ::osl::MutexGuard aGuard( rMutex );
182 typename InterfaceMap::iterator iter = m_pMap->begin();
183 typename InterfaceMap::iterator end = m_pMap->end();
184
185 while( iter != end )
186 {
187 static_cast<OInterfaceContainerHelper*>((*iter).second)->clear();
188 ++iter;
189 }
190}
191
192
193}
194
195#endif
196
197/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
config.h
interfacecontainer.h
cppu
Definition: Enterable.hxx:31
osl::Mutex
A mutual exclusion synchronization object.
Definition: mutex.hxx:35
osl::Guard
Object lifetime scoped mutex object or interface lock.
Definition: mutex.hxx:122
cppu::OInterfaceContainerHelper
A container of interfaces.
Definition: interfacecontainer.h:132
cppu::OInterfaceContainerHelper::getLength
sal_Int32 getLength() const
Return the number of Elements in the container.
cppu::OInterfaceContainerHelper::disposeAndClear
void disposeAndClear(const css::lang::EventObject &rEvt)
Call disposing on all object in the container that support XEventListener.
cppu::OInterfaceContainerHelper::addInterface
sal_Int32 addInterface(const css::uno::Reference< css::uno::XInterface > &rxIFace)
Inserts an element into the container.
cppu::OMultiTypeInterfaceContainerHelperVar::~OMultiTypeInterfaceContainerHelperVar
~OMultiTypeInterfaceContainerHelperVar()
Deletes all containers.
Definition: interfacecontainer.hxx:45
cppu::OMultiTypeInterfaceContainerHelperVar::addInterface
sal_Int32 addInterface(const key &rKey, const css::uno::Reference< css::uno::XInterface > &r)
Inserts an element into the container with the specified key.
Definition: interfacecontainer.hxx:106
cppu::OMultiTypeInterfaceContainerHelperVar::getContainer
OInterfaceContainerHelper * getContainer(const key &) const
Return the container created under this key.
Definition: interfacecontainer.hxx:93
cppu::OMultiTypeInterfaceContainerHelperVar::clear
void clear()
Remove all elements of all containers.
Definition: interfacecontainer.hxx:179
cppu::OMultiTypeInterfaceContainerHelperVar::disposeAndClear
void disposeAndClear(const css::lang::EventObject &rEvt)
Call disposing on all references in the container, that support XEventListener.
Definition: interfacecontainer.hxx:142
cppu::OMultiTypeInterfaceContainerHelperVar::OMultiTypeInterfaceContainerHelperVar
OMultiTypeInterfaceContainerHelperVar(::osl::Mutex &rMutex)
Create a container of interface containers.
Definition: interfacecontainer.hxx:37
cppu::OMultiTypeInterfaceContainerHelperVar::getContainedTypes
css::uno::Sequence< key > getContainedTypes() const
Return all id's under which at least one interface is added.
Definition: interfacecontainer.hxx:61
cppu::OMultiTypeInterfaceContainerHelperVar::removeInterface
sal_Int32 removeInterface(const key &rKey, const css::uno::Reference< css::uno::XInterface > &rxIFace)
Removes an element from the container with the specified key.
Definition: interfacecontainer.hxx:124