1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
|
/*************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright 2000, 2010 Oracle and/or its affiliates.
*
* OpenOffice.org - a multi-platform office productivity suite
*
* This file is part of OpenOffice.org.
*
* OpenOffice.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* only, as published by the Free Software Foundation.
*
* OpenOffice.org is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License version 3 for more details
* (a copy is included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU Lesser General Public License
* version 3 along with OpenOffice.org. If not, see
* <http://www.openoffice.org/license.html>
* for a copy of the LGPLv3 License.
*
************************************************************************/
#ifndef CONFIGMGR_BACKEND_CACHECONTROLLER_HXX
#define CONFIGMGR_BACKEND_CACHECONTROLLER_HXX
#include "sal/config.h"
#include "salhelper/simplereferenceobject.hxx"
#include "utility.hxx"
#include "mergeddataprovider.hxx"
#include "cacheaccess.hxx"
#include "cachemulticaster.hxx"
#include "requestoptions.hxx"
#include "autoreferencemap.hxx"
#include <com/sun/star/uno/XComponentContext.hpp>
namespace configmgr
{
// ---------------------------------------------------------------------------
class OTreeDisposeScheduler;
class OCacheWriteScheduler;
// ---------------------------------------------------------------------------
namespace backend
{
// ---------------------------------------------------------------------------
/** manages a shared data cache for configuration data
trying to ensure consistency with a backend
and provides access to the data for clients
*/
class CacheController:
public salhelper::SimpleReferenceObject,
public ITemplateDataProvider, public INodeDataListener
{
public:
/** ctor
*/
explicit
CacheController(rtl::Reference< backend::IMergedDataProvider > const & _xBackend,
const uno::Reference<uno::XComponentContext>& xContext);
// disposing the cache before destroying
void dispose() SAL_THROW((com::sun::star::uno::RuntimeException));
/** locates data of a component in the cache.
<p> If the data isn't in the cache it is loaded from the backend. </p>
@param _aRequest
identifies the component to be loaded.
@returns
data that can be used to locate the loaded data in the cache.
@throws com::sun::star::uno::Exception
if loading the data fails.
The exact exception being thrown may depend on the underlying backend.
*/
sharable::TreeFragment * loadComponent(ComponentRequest const & _aRequest)
SAL_THROW((com::sun::star::uno::Exception));
/** releases data of a component from the cache.
<p> Should be called when a client is done with a component.
Each calls to <method>loadComponent</method> should
be balanced by exactly one call to <method>freeComponent</method>.
</p>
@param _aRequest
identifies a component previously loaded via <method>loadComponent</method>.
@returns
data that can be used to locate the loaded data in the cache.
*/
void freeComponent(ComponentRequest const & _aRequest)
SAL_THROW(());
/** refreshes data of an existing component from the backend
<p> If the data is in the cache already, it is refreshed from the
backend and the change are notified to all registered listeners.
</p>
<p> If the data isn't in the cache nothing is done and
a NULL location is returned.
</p>
<p>Note: the caller <strong>must not</strong> hold any lock on the cache line affected.</p>
@param _aRequest
identifies the component to be refreshed.
@returns
data that can be used to locate the refreshed data in the cache.
<p>If there is no data to refresh a NULL location is returned.</p>
@throws com::sun::star::uno::Exception
if loading the data fails.
The exact exception being thrown may depend on the underlying backend.
*/
sharable::TreeFragment * refreshComponent(ComponentRequest const & _aRequest)
SAL_THROW((com::sun::star::uno::Exception));
/** refreshes data of all existing components from the backend
<p> If the data is in the cache already, it is refreshed from the
backend and the change are notified to all registered listeners.
</p>
<p> If the data isn't in the cache nothing is done and
a NULL location is returned.
</p>
<p>Note: the caller <strong>must not</strong> hold any lock on the cache line affected.</p>
@throws com::sun::star::uno::Exception
if loading the data fails.
The exact exception being thrown may depend on the underlying backend.
*/
void refreshAllComponents()
SAL_THROW((com::sun::star::uno::Exception));
/** flushes data of all pending updates from cache to the backend(s)
@throws com::sun::star::uno::Exception
if flushing the data fails.
The exact exception being thrown may depend on the underlying backend.
*/
void flushPendingUpdates() SAL_THROW((com::sun::star::uno::Exception));
/** locates a template in the cache.
<p> If the data isn't in the cache it is loaded from the backend. </p>
<p>Note: the caller <strong>must not</strong> hold any lock on the cache line affected.</p>
@param _aRequest
identifies the template to be loaded.
@returns
data that can be used to locate the template data in the cache.
@throws com::sun::star::uno::Exception
if loading the template data fails.
The exact exception being thrown may depend on the underlying backend.
*/
sharable::TreeFragment * loadTemplate(TemplateRequest const & _aRequest)
SAL_THROW((com::sun::star::uno::Exception));
/** saves changes to the backend and notifies them to registered listeners.
<p> Must be called after the changes have been applied to the cache
and before any subsequent changes to the same component.
</p>
<p> Notifications are guaranteed to be delivered
before any subsequent changes to the same component are possible.
</p>
<p> Note: the caller <strong>must</strong> hold a read lock (but no write lock)
on the cache line affected during the call.</p>
@param _anUpdate
identifies the node that changed and describes the changes.
@throws com::sun::star::uno::Exception
if saving the changes to the backend fails.
The exact exception being thrown may depend on the underlying backend.
*/
void saveAndNotify(UpdateRequest const & _anUpdate)
SAL_THROW((com::sun::star::uno::Exception));
/** @returns
an object that can used to broadcast changes done through this object.
<p> The object returned is guaranteed to live as long
as this object lives.
</p>
*/
CacheChangeMulticaster & getNotifier() SAL_THROW(())
{ return m_aNotifier; }
/** loads merged data for a (complete) tree and returns it as return value.
@param _aRequest
identifies the component to be loaded
@param __bAddListenter
identifies is listener is to be registered to backend
@returns
A valid component instance for the given component.
@throws com::sun::star::uno::Exception
if the node cannot be retrieved.
The exact exception being thrown may depend on the underlying backend.
*/
ResultHolder< ComponentInstance > getComponentData(ComponentRequest const & _aRequest,
bool _bAddListenter)
SAL_THROW((com::sun::star::uno::Exception));
/** loads default data for a (partial) tree and returns it as return value
@param _aRequest
identifies the node to be loaded
@returns
A valid node instance for the default state of the given node.
<p>May be NULL, if the node exists but has no default equivalent.</p>
@throws com::sun::star::uno::Exception
if the default cannot be retrieved.
The exact exception being thrown may depend on the underlying backend.
*/
ResultHolder< NodeInstance > getDefaultData(NodeRequest const & _aRequest)
SAL_THROW((com::sun::star::uno::Exception));
/** loads a given template and returns it as return value
@param _aRequest
identifies the template to be loaded
@returns
A valid instance of the given template.
<p> Currently a request with empty template name
will retrieve a group node holding all templates
of a component.
</p>
@throws com::sun::star::uno::Exception
if the template cannot be retrieved.
The exact exception being thrown may depend on the underlying backend.
*/
virtual ResultHolder< TemplateInstance > getTemplateData(TemplateRequest const & _aRequest)
SAL_THROW((com::sun::star::uno::Exception));
//INodeDataListener Implementation
/** Triggered when component data is changed
@param _aRequest
identifies the data that changed
*/
virtual void dataChanged(const ComponentRequest& _aRequest) SAL_THROW(());
protected:
// ref counted, that's why no public dtor
~CacheController();
// implementation
private:
configuration::AbsolutePath encodeTemplateLocation(rtl::OUString const & _rName, rtl::OUString const & _rModule) const;
configuration::AbsolutePath ensureTemplate(rtl::OUString const& _rName, rtl::OUString const& _rModule) SAL_THROW((com::sun::star::uno::Exception));
// adjust a node result for locale, ...
bool normalizeResult(std::auto_ptr<ISubtree> & _aResult, RequestOptions const & _aOptions);
// reads data from the backend directly
ResultHolder< ComponentInstance > loadDirectly(ComponentRequest const & _aRequest, bool _bAddListenter )
SAL_THROW((com::sun::star::uno::Exception));
// reads default data from the backend directly
ResultHolder< NodeInstance > loadDefaultsDirectly(NodeRequest const & _aRequest) SAL_THROW((com::sun::star::uno::Exception));
// writes an update to the backend directly
void saveDirectly(UpdateRequest const & _anUpdate) SAL_THROW((com::sun::star::uno::Exception));
// writes updates for a component to the backend directly
void savePendingChanges(rtl::Reference<CacheLoadingAccess> const & _aCache, ComponentRequest const & _aComponent)
SAL_THROW((com::sun::star::uno::Exception));
// saves all pending changes from a cache access to the backend
bool saveAllPendingChanges(rtl::Reference<CacheLoadingAccess> const & _aCache, RequestOptions const & _aOptions)
SAL_THROW((com::sun::star::uno::RuntimeException));
// load templates componentwise from backend
std::auto_ptr<ISubtree> loadTemplateData(TemplateRequest const & _aRequest)
SAL_THROW((com::sun::star::uno::Exception));
void flushCacheWriter() SAL_THROW(());
// add templates componentwise to cache
sharable::TreeFragment * addTemplates ( backend::ComponentDataStruct const & _aComponentInstance );
rtl::Reference<CacheLoadingAccess> getCacheAlways(RequestOptions const & _aOptions);
OTreeDisposeScheduler * createDisposer(const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XComponentContext >& _xContext);
OCacheWriteScheduler * createCacheWriter(const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XComponentContext >& _xContext);
// disposing
void disposeAll(bool _bFlushRemainingUpdates);
void closeModules(std::vector< rtl::Reference<CacheLine> > & _aList, RequestOptions const & _aOptions);
private:
typedef AutoReferenceMap<RequestOptions,CacheLoadingAccess,lessRequestOptions> CacheMap;
CacheChangeMulticaster m_aNotifier;
rtl::Reference< backend::IMergedDataProvider > m_xBackend;
CacheMap m_aCacheMap;
TemplateCacheData m_aTemplates;
OTreeDisposeScheduler* m_pDisposer;
OCacheWriteScheduler * m_pCacheWriter;
bool m_bDisposing; // disables async writing and automatic refresh
friend class configmgr::OTreeDisposeScheduler;
friend class configmgr::OCacheWriteScheduler;
friend class OInvalidateTreeThread;
};
// ---------------------------------------------------------------------------
} // namespace backend
// ---------------------------------------------------------------------------
} // namespace configmgr
#endif
|
