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 :
20 :
21 : /**************************************************************************
22 : TODO
23 : **************************************************************************
24 :
25 : Note: Configuration Management classes do not support XAggregation.
26 : So I have to wrap the interesting interfaces manually.
27 :
28 : *************************************************************************/
29 : #include "hierarchydatasource.hxx"
30 : #include <osl/diagnose.h>
31 :
32 : #include "osl/doublecheckedlocking.h"
33 : #include <comphelper/processfactory.hxx>
34 : #include <cppuhelper/interfacecontainer.hxx>
35 : #include <com/sun/star/beans/PropertyValue.hpp>
36 : #include <com/sun/star/configuration/theDefaultProvider.hpp>
37 : #include <com/sun/star/container/XHierarchicalNameAccess.hpp>
38 : #include <com/sun/star/container/XNameContainer.hpp>
39 : #include <com/sun/star/util/XChangesBatch.hpp>
40 : #include <com/sun/star/util/XChangesNotifier.hpp>
41 :
42 : using namespace com::sun::star;
43 : using namespace hierarchy_ucp;
44 :
45 :
46 :
47 : // describe path of cfg entry
48 : #define CFGPROPERTY_NODEPATH "nodepath"
49 : // true->async. update; false->sync. update
50 : #define CFGPROPERTY_LAZYWRITE "lazywrite"
51 :
52 : #define READ_SERVICE_NAME "com.sun.star.ucb.HierarchyDataReadAccess"
53 : #define READWRITE_SERVICE_NAME "com.sun.star.ucb.HierarchyDataReadWriteAccess"
54 :
55 : #define CONFIG_READ_SERVICE_NAME \
56 : "com.sun.star.configuration.ConfigurationAccess"
57 : #define CONFIG_READWRITE_SERVICE_NAME \
58 : "com.sun.star.configuration.ConfigurationUpdateAccess"
59 : #define CONFIG_DATA_ROOT_KEY \
60 : "/org.openoffice.ucb.Hierarchy/Root"
61 :
62 :
63 :
64 : namespace hcp_impl
65 : {
66 :
67 :
68 :
69 : // HierarchyDataReadAccess Implementation.
70 :
71 :
72 :
73 : class HierarchyDataAccess : public cppu::OWeakObject,
74 : public lang::XServiceInfo,
75 : public lang::XTypeProvider,
76 : public lang::XComponent,
77 : public lang::XSingleServiceFactory,
78 : public container::XHierarchicalNameAccess,
79 : public container::XNameContainer,
80 : public util::XChangesNotifier,
81 : public util::XChangesBatch
82 : {
83 : osl::Mutex m_aMutex;
84 : uno::Reference< uno::XInterface > m_xConfigAccess;
85 : uno::Reference< lang::XComponent > m_xCfgC;
86 : uno::Reference< lang::XSingleServiceFactory > m_xCfgSSF;
87 : uno::Reference< container::XHierarchicalNameAccess > m_xCfgHNA;
88 : uno::Reference< container::XNameContainer > m_xCfgNC;
89 : uno::Reference< container::XNameReplace > m_xCfgNR;
90 : uno::Reference< container::XNameAccess > m_xCfgNA;
91 : uno::Reference< container::XElementAccess > m_xCfgEA;
92 : uno::Reference< util::XChangesNotifier > m_xCfgCN;
93 : uno::Reference< util::XChangesBatch > m_xCfgCB;
94 : bool m_bReadOnly;
95 :
96 : public:
97 : HierarchyDataAccess( const uno::Reference<
98 : uno::XInterface > & xConfigAccess,
99 : bool bReadOnly );
100 : virtual ~HierarchyDataAccess();
101 :
102 : // XInterface
103 : virtual css::uno::Any SAL_CALL queryInterface( const css::uno::Type & rType )
104 : throw( css::uno::RuntimeException, std::exception ) SAL_OVERRIDE;
105 : virtual void SAL_CALL acquire()
106 : throw() SAL_OVERRIDE;
107 : virtual void SAL_CALL release()
108 : throw() SAL_OVERRIDE;
109 :
110 : // XServiceInfo
111 : virtual OUString SAL_CALL getImplementationName()
112 : throw( css::uno::RuntimeException, std::exception ) SAL_OVERRIDE;
113 : virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName )
114 : throw( css::uno::RuntimeException, std::exception ) SAL_OVERRIDE;
115 : virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames()
116 : throw( css::uno::RuntimeException, std::exception ) SAL_OVERRIDE;
117 :
118 : static OUString getImplementationName_Static();
119 : static css::uno::Sequence< OUString > getSupportedServiceNames_Static();
120 :
121 : static css::uno::Reference< css::lang::XSingleServiceFactory >
122 : createServiceFactory( const css::uno::Reference<
123 : css::lang::XMultiServiceFactory >& rxServiceMgr );
124 :
125 : // XTypeProvider
126 : virtual css::uno::Sequence< sal_Int8 > SAL_CALL getImplementationId()
127 : throw( css::uno::RuntimeException, std::exception ) SAL_OVERRIDE;
128 : virtual css::uno::Sequence< com::sun::star::uno::Type > SAL_CALL getTypes()
129 : throw( css::uno::RuntimeException, std::exception ) SAL_OVERRIDE;
130 :
131 : // XComponent
132 : virtual void SAL_CALL
133 : dispose()
134 : throw ( uno::RuntimeException, std::exception ) SAL_OVERRIDE;
135 : virtual void SAL_CALL
136 : addEventListener( const uno::Reference< lang::XEventListener > & xListener )
137 : throw ( uno::RuntimeException, std::exception ) SAL_OVERRIDE;
138 : virtual void SAL_CALL
139 : removeEventListener( const uno::Reference<
140 : lang::XEventListener > & aListener )
141 : throw ( uno::RuntimeException, std::exception ) SAL_OVERRIDE;
142 :
143 : // XSingleServiceFactory
144 : virtual uno::Reference< uno::XInterface > SAL_CALL
145 : createInstance()
146 : throw ( uno::Exception, uno::RuntimeException, std::exception ) SAL_OVERRIDE;
147 : virtual uno::Reference< uno::XInterface > SAL_CALL
148 : createInstanceWithArguments( const uno::Sequence< uno::Any > & aArguments )
149 : throw ( uno::Exception, uno::RuntimeException, std::exception ) SAL_OVERRIDE;
150 :
151 : // XHierarchicalNameAccess
152 : virtual uno::Any SAL_CALL
153 : getByHierarchicalName( const OUString & aName )
154 : throw ( container::NoSuchElementException, uno::RuntimeException, std::exception ) SAL_OVERRIDE;
155 : virtual sal_Bool SAL_CALL
156 : hasByHierarchicalName( const OUString & aName )
157 : throw ( uno::RuntimeException, std::exception ) SAL_OVERRIDE;
158 :
159 : // XNameContainer
160 : virtual void SAL_CALL
161 : insertByName( const OUString & aName, const uno::Any & aElement )
162 : throw ( lang::IllegalArgumentException,
163 : container::ElementExistException,
164 : lang::WrappedTargetException,
165 : uno::RuntimeException, std::exception ) SAL_OVERRIDE;
166 : virtual void SAL_CALL
167 : removeByName( const OUString & Name )
168 : throw ( container::NoSuchElementException,
169 : lang::WrappedTargetException,
170 : uno::RuntimeException, std::exception ) SAL_OVERRIDE;
171 :
172 : // XNameReplace ( base of XNameContainer )
173 : virtual void SAL_CALL
174 : replaceByName( const OUString & aName, const uno::Any & aElement )
175 : throw ( lang::IllegalArgumentException,
176 : container::NoSuchElementException,
177 : lang::WrappedTargetException,
178 : uno::RuntimeException, std::exception ) SAL_OVERRIDE;
179 :
180 : // XNameAccess ( base of XNameReplace )
181 : virtual uno::Any SAL_CALL
182 : getByName( const OUString & aName )
183 : throw ( container::NoSuchElementException,
184 : lang::WrappedTargetException,
185 : uno::RuntimeException, std::exception ) SAL_OVERRIDE;
186 : virtual uno::Sequence< OUString > SAL_CALL
187 : getElementNames()
188 : throw ( uno::RuntimeException, std::exception ) SAL_OVERRIDE;
189 : virtual sal_Bool SAL_CALL
190 : hasByName( const OUString & aName )
191 : throw ( uno::RuntimeException, std::exception ) SAL_OVERRIDE;
192 :
193 : // XElementAccess ( base of XNameAccess )
194 : virtual uno::Type SAL_CALL
195 : getElementType()
196 : throw ( uno::RuntimeException, std::exception ) SAL_OVERRIDE;
197 : virtual sal_Bool SAL_CALL
198 : hasElements()
199 : throw ( uno::RuntimeException, std::exception ) SAL_OVERRIDE;
200 :
201 : // XChangesNotifier
202 : virtual void SAL_CALL
203 : addChangesListener( const uno::Reference<
204 : util::XChangesListener > & aListener )
205 : throw ( uno::RuntimeException, std::exception ) SAL_OVERRIDE;
206 : virtual void SAL_CALL
207 : removeChangesListener( const uno::Reference<
208 : util::XChangesListener > & aListener )
209 : throw ( uno::RuntimeException, std::exception ) SAL_OVERRIDE;
210 :
211 : // XChangesBatch
212 : virtual void SAL_CALL
213 : commitChanges()
214 : throw ( lang::WrappedTargetException, uno::RuntimeException, std::exception ) SAL_OVERRIDE;
215 : virtual sal_Bool SAL_CALL
216 : hasPendingChanges()
217 : throw ( uno::RuntimeException, std::exception ) SAL_OVERRIDE;
218 : virtual uno::Sequence< util::ElementChange > SAL_CALL
219 : getPendingChanges()
220 : throw ( uno::RuntimeException, std::exception ) SAL_OVERRIDE;
221 : };
222 :
223 : } // namespace hcp_impl
224 :
225 : using namespace hcp_impl;
226 :
227 :
228 :
229 :
230 : // HierarchyDataSource Implementation.
231 :
232 :
233 :
234 :
235 0 : HierarchyDataSource::HierarchyDataSource(
236 : const uno::Reference< uno::XComponentContext > & rxContext )
237 : : m_xContext( rxContext ),
238 0 : m_pDisposeEventListeners( 0 )
239 : {
240 0 : }
241 :
242 :
243 : // virtual
244 0 : HierarchyDataSource::~HierarchyDataSource()
245 : {
246 0 : delete m_pDisposeEventListeners;
247 0 : }
248 :
249 :
250 :
251 : // XInterface methods.
252 0 : void SAL_CALL HierarchyDataSource::acquire()
253 : throw()
254 : {
255 0 : OWeakObject::acquire();
256 0 : }
257 :
258 0 : void SAL_CALL HierarchyDataSource::release()
259 : throw()
260 : {
261 0 : OWeakObject::release();
262 0 : }
263 :
264 0 : css::uno::Any SAL_CALL HierarchyDataSource::queryInterface( const css::uno::Type & rType )
265 : throw( css::uno::RuntimeException, std::exception )
266 : {
267 : css::uno::Any aRet = cppu::queryInterface( rType,
268 : (static_cast< lang::XTypeProvider* >(this)),
269 : (static_cast< lang::XServiceInfo* >(this)),
270 : (static_cast< lang::XComponent* >(this)),
271 : (static_cast< lang::XMultiServiceFactory* >(this))
272 0 : );
273 0 : return aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType );
274 : }
275 :
276 : // XTypeProvider methods.
277 :
278 :
279 :
280 0 : XTYPEPROVIDER_IMPL_4( HierarchyDataSource,
281 : lang::XTypeProvider,
282 : lang::XServiceInfo,
283 : lang::XComponent,
284 : lang::XMultiServiceFactory );
285 :
286 :
287 :
288 : // XServiceInfo methods.
289 :
290 :
291 :
292 0 : XSERVICEINFO_IMPL_0_CTX( HierarchyDataSource,
293 : OUString( "com.sun.star.comp.ucb.HierarchyDataSource" ) )
294 : {
295 0 : uno::Sequence< OUString > aSNS( 2 );
296 0 : aSNS[ 0 ] = "com.sun.star.ucb.DefaultHierarchyDataSource";
297 0 : aSNS[ 1 ] = "com.sun.star.ucb.HierarchyDataSource";
298 0 : return aSNS;
299 : }
300 :
301 0 : ONE_INSTANCE_SERVICE_FACTORY_IMPL( HierarchyDataSource );
302 :
303 :
304 :
305 : // XComponent methods.
306 :
307 :
308 :
309 : // virtual
310 0 : void SAL_CALL HierarchyDataSource::dispose()
311 : throw( uno::RuntimeException, std::exception )
312 : {
313 0 : osl::Guard< osl::Mutex > aGuard( m_aMutex );
314 :
315 0 : if ( m_pDisposeEventListeners && m_pDisposeEventListeners->getLength() )
316 : {
317 0 : lang::EventObject aEvt;
318 0 : aEvt.Source = static_cast< lang::XComponent * >( this );
319 0 : m_pDisposeEventListeners->disposeAndClear( aEvt );
320 0 : }
321 0 : }
322 :
323 :
324 : // virtual
325 0 : void SAL_CALL HierarchyDataSource::addEventListener(
326 : const uno::Reference< lang::XEventListener > & Listener )
327 : throw( uno::RuntimeException, std::exception )
328 : {
329 0 : osl::Guard< osl::Mutex > aGuard( m_aMutex );
330 :
331 0 : if ( !m_pDisposeEventListeners )
332 : m_pDisposeEventListeners
333 0 : = new cppu::OInterfaceContainerHelper( m_aMutex );
334 :
335 0 : m_pDisposeEventListeners->addInterface( Listener );
336 0 : }
337 :
338 :
339 : // virtual
340 0 : void SAL_CALL HierarchyDataSource::removeEventListener(
341 : const uno::Reference< lang::XEventListener > & Listener )
342 : throw( uno::RuntimeException, std::exception )
343 : {
344 0 : osl::Guard< osl::Mutex > aGuard( m_aMutex );
345 :
346 0 : if ( m_pDisposeEventListeners )
347 0 : m_pDisposeEventListeners->removeInterface( Listener );
348 0 : }
349 :
350 :
351 :
352 : // XMultiServiceFactory methods.
353 :
354 :
355 :
356 : // virtual
357 : uno::Reference< uno::XInterface > SAL_CALL
358 0 : HierarchyDataSource::createInstance( const OUString & aServiceSpecifier )
359 : throw ( uno::Exception, uno::RuntimeException, std::exception )
360 : {
361 : // Create view to root node.
362 :
363 0 : beans::PropertyValue aProp;
364 0 : aProp.Name = CFGPROPERTY_NODEPATH;
365 0 : aProp.Value <<= OUString( CONFIG_DATA_ROOT_KEY );
366 :
367 0 : uno::Sequence< uno::Any > aArguments( 1 );
368 0 : aArguments[ 0 ] <<= aProp;
369 :
370 0 : return createInstanceWithArguments( aServiceSpecifier, aArguments, false );
371 : }
372 :
373 :
374 : // virtual
375 : uno::Reference< uno::XInterface > SAL_CALL
376 0 : HierarchyDataSource::createInstanceWithArguments(
377 : const OUString & ServiceSpecifier,
378 : const uno::Sequence< uno::Any > & Arguments )
379 : throw ( uno::Exception, uno::RuntimeException, std::exception )
380 : {
381 0 : return createInstanceWithArguments( ServiceSpecifier, Arguments, true );
382 : }
383 :
384 :
385 : // virtual
386 : uno::Sequence< OUString > SAL_CALL
387 0 : HierarchyDataSource::getAvailableServiceNames()
388 : throw ( uno::RuntimeException, std::exception )
389 : {
390 0 : uno::Sequence< OUString > aNames( 2 );
391 0 : aNames[ 0 ] = READ_SERVICE_NAME;
392 0 : aNames[ 1 ] = READWRITE_SERVICE_NAME;
393 0 : return aNames;
394 : }
395 :
396 :
397 :
398 : // Non-interface methods
399 :
400 :
401 :
402 : uno::Reference< uno::XInterface > SAL_CALL
403 0 : HierarchyDataSource::createInstanceWithArguments(
404 : const OUString & ServiceSpecifier,
405 : const uno::Sequence< uno::Any > & Arguments,
406 : bool bCheckArgs )
407 : throw ( uno::Exception, uno::RuntimeException )
408 : {
409 0 : osl::Guard< osl::Mutex > aGuard( m_aMutex );
410 :
411 : // Check service specifier.
412 0 : bool bReadOnly = ServiceSpecifier == READ_SERVICE_NAME;
413 0 : bool bReadWrite = !bReadOnly && ServiceSpecifier == READWRITE_SERVICE_NAME;
414 :
415 0 : if ( !bReadOnly && !bReadWrite )
416 : {
417 : OSL_FAIL( "HierarchyDataSource::createInstanceWithArguments - "
418 : "Unsupported service specifier!" );
419 0 : return uno::Reference< uno::XInterface >();
420 : }
421 :
422 0 : uno::Sequence< uno::Any > aNewArgs( Arguments );
423 :
424 0 : bool bHasLazyWriteProp = bReadOnly; // property must be added only if
425 : // a writable view is requested.
426 0 : if ( bCheckArgs )
427 : {
428 : // Check arguments.
429 0 : bool bHasNodePath = false;
430 0 : sal_Int32 nCount = Arguments.getLength();
431 0 : for ( sal_Int32 n = 0; n < nCount; ++n )
432 : {
433 0 : beans::PropertyValue aProp;
434 0 : if ( Arguments[ n ] >>= aProp )
435 : {
436 0 : if ( aProp.Name == CFGPROPERTY_NODEPATH )
437 : {
438 0 : OUString aPath;
439 0 : if ( aProp.Value >>= aPath )
440 : {
441 0 : bHasNodePath = true;
442 :
443 : // Create path to data inside the configuration.
444 0 : OUString aConfigPath;
445 0 : if ( !createConfigPath( aPath, aConfigPath ) )
446 : {
447 : OSL_FAIL( "HierarchyDataSource::"
448 : "createInstanceWithArguments - "
449 : "Invalid node path!" );
450 0 : return uno::Reference< uno::XInterface >();
451 : }
452 :
453 0 : aProp.Value <<= aConfigPath;
454 :
455 : // Set new path in arguments.
456 0 : aNewArgs[ n ] <<= aProp;
457 :
458 0 : if ( bHasLazyWriteProp )
459 0 : break;
460 : }
461 : else
462 : {
463 : OSL_FAIL( "HierarchyDataSource::createInstanceWithArguments - "
464 : "Invalid type for property 'nodepath'!" );
465 0 : return uno::Reference< uno::XInterface >();
466 0 : }
467 : }
468 0 : else if ( aProp.Name == CFGPROPERTY_LAZYWRITE )
469 : {
470 0 : if ( aProp.Value.getValueType() == getCppuBooleanType() )
471 : {
472 0 : bHasLazyWriteProp = true;
473 :
474 0 : if ( bHasNodePath )
475 0 : break;
476 : }
477 : else
478 : {
479 : OSL_FAIL( "HierarchyDataSource::createInstanceWithArguments - "
480 : "Invalid type for property 'lazywrite'!" );
481 0 : return uno::Reference< uno::XInterface >();
482 : }
483 : }
484 : }
485 0 : }
486 :
487 0 : if ( !bHasNodePath )
488 : {
489 : OSL_FAIL( "HierarchyDataSource::createInstanceWithArguments - "
490 : "No 'nodepath' property!" );
491 0 : return uno::Reference< uno::XInterface >();
492 : }
493 : }
494 :
495 : // Create Configuration Provider.
496 0 : uno::Reference< lang::XMultiServiceFactory > xProv = getConfigProvider();
497 0 : if ( !xProv.is() )
498 0 : return uno::Reference< uno::XInterface >();
499 :
500 0 : uno::Reference< uno::XInterface > xConfigAccess;
501 : try
502 : {
503 0 : if ( bReadOnly )
504 : {
505 : // Create configuration read-only access object.
506 0 : xConfigAccess = xProv->createInstanceWithArguments(
507 : OUString( CONFIG_READ_SERVICE_NAME ),
508 0 : aNewArgs );
509 : }
510 : else
511 : {
512 : // Append 'lazywrite' property value, if not already present.
513 0 : if ( !bHasLazyWriteProp )
514 : {
515 0 : sal_Int32 nLen = aNewArgs.getLength();
516 0 : aNewArgs.realloc( nLen + 1 );
517 :
518 0 : beans::PropertyValue aProp;
519 0 : aProp.Name = CFGPROPERTY_LAZYWRITE;
520 0 : aProp.Value <<= sal_True;
521 0 : aNewArgs[ nLen ] <<= aProp;
522 : }
523 :
524 : // Create configuration read-write access object.
525 0 : xConfigAccess = xProv->createInstanceWithArguments(
526 : OUString( CONFIG_READWRITE_SERVICE_NAME ),
527 0 : aNewArgs );
528 : }
529 : }
530 0 : catch ( uno::Exception const & )
531 : {
532 : OSL_FAIL( "HierarchyDataSource::createInstanceWithArguments - "
533 : "Cannot instanciate configuration access!" );
534 0 : throw;
535 : }
536 :
537 0 : if ( !xConfigAccess.is() )
538 : {
539 : OSL_FAIL( "HierarchyDataSource::createInstanceWithArguments - "
540 : "Cannot instanciate configuration access!" );
541 0 : return xConfigAccess;
542 : }
543 :
544 : return uno::Reference< uno::XInterface >(
545 : static_cast< cppu::OWeakObject * >(
546 0 : new HierarchyDataAccess( xConfigAccess, bReadOnly ) ) );
547 : }
548 :
549 :
550 : uno::Reference< lang::XMultiServiceFactory >
551 0 : HierarchyDataSource::getConfigProvider()
552 : {
553 0 : if ( !m_xConfigProvider.is() )
554 : {
555 0 : osl::Guard< osl::Mutex > aGuard( m_aMutex );
556 0 : if ( !m_xConfigProvider.is() )
557 : {
558 : try
559 : {
560 0 : m_xConfigProvider = configuration::theDefaultProvider::get( m_xContext );
561 : }
562 0 : catch ( uno::Exception const & )
563 : {
564 : OSL_FAIL( "HierarchyDataSource::getConfigProvider - "
565 : "caught exception!" );
566 : }
567 0 : }
568 : }
569 :
570 0 : return m_xConfigProvider;
571 : }
572 :
573 :
574 0 : bool HierarchyDataSource::createConfigPath(
575 : const OUString & rInPath, OUString & rOutPath )
576 : {
577 0 : if ( !rInPath.isEmpty() )
578 : {
579 0 : if ( rInPath.startsWith( "/" ) )
580 : {
581 : OSL_FAIL( "HierarchyDataSource::createConfigPath - "
582 : "Leading slash in node path!" );
583 0 : return false;
584 : }
585 :
586 0 : if ( rInPath.endsWith( "/" ) )
587 : {
588 : OSL_FAIL( "HierarchyDataSource::createConfigPath - "
589 : "Trailing slash in node path!" );
590 0 : return false;
591 : }
592 :
593 0 : rOutPath = CONFIG_DATA_ROOT_KEY "/" + rInPath;
594 : }
595 : else
596 : {
597 0 : rOutPath = CONFIG_DATA_ROOT_KEY;
598 : }
599 :
600 0 : return true;
601 : }
602 :
603 :
604 :
605 :
606 : // HierarchyDataAccess Implementation.
607 :
608 :
609 :
610 :
611 : #define ENSURE_ORIG_INTERFACE( interface_name, member_name ) \
612 : m_xCfg##member_name; \
613 : if ( !m_xCfg##member_name.is() ) \
614 : { \
615 : osl::Guard< osl::Mutex > aGuard( m_aMutex ); \
616 : if ( !m_xCfg##member_name.is() ) \
617 : m_xCfg##member_name \
618 : = uno::Reference< interface_name >( \
619 : m_xConfigAccess, uno::UNO_QUERY ); \
620 : xOrig = m_xCfg##member_name; \
621 : }
622 :
623 :
624 0 : HierarchyDataAccess::HierarchyDataAccess( const uno::Reference<
625 : uno::XInterface > & xConfigAccess,
626 : bool bReadOnly )
627 : : m_xConfigAccess( xConfigAccess ),
628 0 : m_bReadOnly( bReadOnly )
629 : {
630 0 : }
631 :
632 :
633 : // virtual
634 0 : HierarchyDataAccess::~HierarchyDataAccess()
635 : {
636 0 : }
637 :
638 :
639 :
640 : // XInterface methods.
641 0 : void SAL_CALL HierarchyDataAccess::acquire()
642 : throw()
643 : {
644 0 : OWeakObject::acquire();
645 0 : }
646 :
647 0 : void SAL_CALL HierarchyDataAccess::release()
648 : throw()
649 : {
650 0 : OWeakObject::release();
651 0 : }
652 :
653 : // virtual
654 0 : uno::Any SAL_CALL HierarchyDataAccess::queryInterface( const uno::Type & aType )
655 : throw ( uno::RuntimeException, std::exception )
656 : {
657 : // Interfaces supported in read-only and read-write mode.
658 : uno::Any aRet = cppu::queryInterface( aType,
659 : static_cast< lang::XTypeProvider * >( this ),
660 : static_cast< lang::XServiceInfo * >( this ),
661 : static_cast< lang::XComponent * >( this ),
662 : static_cast< container::XHierarchicalNameAccess * >( this ),
663 : static_cast< container::XNameAccess * >( this ),
664 : static_cast< container::XElementAccess * >( this ),
665 0 : static_cast< util::XChangesNotifier * >( this ) );
666 :
667 : // Interfaces supported only in read-write mode.
668 0 : if ( !aRet.hasValue() && !m_bReadOnly )
669 : {
670 0 : aRet = cppu::queryInterface( aType,
671 : static_cast< lang::XSingleServiceFactory * >( this ),
672 : static_cast< container::XNameContainer * >( this ),
673 : static_cast< container::XNameReplace * >( this ),
674 0 : static_cast< util::XChangesBatch * >( this ) );
675 : }
676 :
677 0 : return aRet.hasValue() ? aRet : OWeakObject::queryInterface( aType );
678 : }
679 :
680 :
681 :
682 : // XTypeProvider methods.
683 :
684 :
685 :
686 0 : XTYPEPROVIDER_COMMON_IMPL( HierarchyDataAccess );
687 :
688 :
689 : // virtual
690 0 : uno::Sequence< uno::Type > SAL_CALL HierarchyDataAccess::getTypes()
691 : throw( uno::RuntimeException, std::exception )
692 : {
693 0 : cppu::OTypeCollection * pCollection = 0;
694 :
695 0 : if ( m_bReadOnly )
696 : {
697 : static cppu::OTypeCollection* pReadOnlyTypes = 0;
698 :
699 0 : pCollection = pReadOnlyTypes;
700 0 : if ( !pCollection )
701 : {
702 0 : osl::Guard< osl::Mutex > aGuard( osl::Mutex::getGlobalMutex() );
703 :
704 0 : pCollection = pReadOnlyTypes;
705 0 : if ( !pCollection )
706 : {
707 : static cppu::OTypeCollection aCollection(
708 0 : CPPU_TYPE_REF( lang::XTypeProvider ),
709 0 : CPPU_TYPE_REF( lang::XServiceInfo ),
710 0 : CPPU_TYPE_REF( lang::XComponent ),
711 0 : CPPU_TYPE_REF( container::XHierarchicalNameAccess ),
712 0 : CPPU_TYPE_REF( container::XNameAccess ),
713 0 : CPPU_TYPE_REF( util::XChangesNotifier ) );
714 0 : pCollection = &aCollection;
715 : OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER();
716 0 : pReadOnlyTypes = pCollection;
717 0 : }
718 : }
719 : else {
720 : OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER();
721 : }
722 : }
723 : else
724 : {
725 : static cppu::OTypeCollection* pReadWriteTypes = 0;
726 :
727 0 : pCollection = pReadWriteTypes;
728 0 : if ( !pCollection )
729 : {
730 0 : osl::Guard< osl::Mutex > aGuard( osl::Mutex::getGlobalMutex() );
731 :
732 0 : pCollection = pReadWriteTypes;
733 0 : if ( !pCollection )
734 : {
735 : static cppu::OTypeCollection aCollection(
736 0 : CPPU_TYPE_REF( lang::XTypeProvider ),
737 0 : CPPU_TYPE_REF( lang::XServiceInfo ),
738 0 : CPPU_TYPE_REF( lang::XComponent ),
739 0 : CPPU_TYPE_REF( lang::XSingleServiceFactory ),
740 0 : CPPU_TYPE_REF( container::XHierarchicalNameAccess ),
741 0 : CPPU_TYPE_REF( container::XNameContainer ),
742 0 : CPPU_TYPE_REF( util::XChangesBatch ),
743 0 : CPPU_TYPE_REF( util::XChangesNotifier ) );
744 0 : pCollection = &aCollection;
745 : OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER();
746 0 : pReadWriteTypes = pCollection;
747 0 : }
748 : }
749 : else {
750 : OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER();
751 : }
752 : }
753 :
754 0 : return (*pCollection).getTypes();
755 : }
756 :
757 :
758 :
759 : // XServiceInfo methods.
760 :
761 :
762 :
763 0 : XSERVICEINFO_NOFACTORY_IMPL_0(
764 : HierarchyDataAccess,
765 : OUString( "com.sun.star.comp.ucb.HierarchyDataAccess" ) )
766 : {
767 0 : uno::Sequence< OUString > aSNS( 2 );
768 0 : aSNS[ 0 ] = READ_SERVICE_NAME;
769 0 : aSNS[ 1 ] = READWRITE_SERVICE_NAME;
770 0 : return aSNS;
771 : }
772 :
773 :
774 :
775 : // XComponent methods.
776 :
777 :
778 :
779 : // virtual
780 0 : void SAL_CALL HierarchyDataAccess::dispose()
781 : throw ( uno::RuntimeException, std::exception )
782 : {
783 : uno::Reference< lang::XComponent > xOrig
784 0 : = ENSURE_ORIG_INTERFACE( lang::XComponent, C );
785 :
786 : OSL_ENSURE( xOrig.is(),
787 : "HierarchyDataAccess : Data source is not an XComponent!" );
788 0 : xOrig->dispose();
789 0 : }
790 :
791 :
792 : // virtual
793 0 : void SAL_CALL HierarchyDataAccess::addEventListener(
794 : const uno::Reference< lang::XEventListener > & xListener )
795 : throw ( uno::RuntimeException, std::exception )
796 : {
797 : uno::Reference< lang::XComponent > xOrig
798 0 : = ENSURE_ORIG_INTERFACE( lang::XComponent, C );
799 :
800 : OSL_ENSURE( xOrig.is(),
801 : "HierarchyDataAccess : Data source is not an XComponent!" );
802 0 : xOrig->addEventListener( xListener );
803 0 : }
804 :
805 :
806 : // virtual
807 0 : void SAL_CALL HierarchyDataAccess::removeEventListener(
808 : const uno::Reference< lang::XEventListener > & aListener )
809 : throw ( uno::RuntimeException, std::exception )
810 : {
811 : uno::Reference< lang::XComponent > xOrig
812 0 : = ENSURE_ORIG_INTERFACE( lang::XComponent, C );
813 :
814 : OSL_ENSURE( xOrig.is(),
815 : "HierarchyDataAccess : Data source is not an XComponent!" );
816 0 : xOrig->removeEventListener( aListener );
817 0 : }
818 :
819 :
820 :
821 : // XHierarchicalNameAccess methods.
822 :
823 :
824 :
825 : // virtual
826 0 : uno::Any SAL_CALL HierarchyDataAccess::getByHierarchicalName(
827 : const OUString & aName )
828 : throw ( container::NoSuchElementException, uno::RuntimeException, std::exception )
829 : {
830 : uno::Reference< container::XHierarchicalNameAccess > xOrig
831 0 : = ENSURE_ORIG_INTERFACE( container::XHierarchicalNameAccess, HNA );
832 :
833 : OSL_ENSURE( xOrig.is(),
834 : "HierarchyDataAccess : "
835 : "Data source is not an XHierarchicalNameAccess!" );
836 0 : return xOrig->getByHierarchicalName( aName );
837 : }
838 :
839 :
840 : // virtual
841 0 : sal_Bool SAL_CALL HierarchyDataAccess::hasByHierarchicalName(
842 : const OUString & aName )
843 : throw ( uno::RuntimeException, std::exception )
844 : {
845 : uno::Reference< container::XHierarchicalNameAccess > xOrig
846 0 : = ENSURE_ORIG_INTERFACE( container::XHierarchicalNameAccess, HNA );
847 :
848 : OSL_ENSURE( xOrig.is(),
849 : "HierarchyDataAccess : "
850 : "Data source is not an XHierarchicalNameAccess!" );
851 0 : return xOrig->hasByHierarchicalName( aName );
852 : }
853 :
854 :
855 :
856 : // XNameAccess methods.
857 :
858 :
859 :
860 : // virtual
861 0 : uno::Any SAL_CALL HierarchyDataAccess::getByName( const OUString & aName )
862 : throw ( container::NoSuchElementException,
863 : lang::WrappedTargetException,
864 : uno::RuntimeException, std::exception )
865 : {
866 : uno::Reference< container::XNameAccess > xOrig
867 0 : = ENSURE_ORIG_INTERFACE( container::XNameAccess, NA );
868 :
869 : OSL_ENSURE( xOrig.is(),
870 : "HierarchyDataAccess : Data source is not an XNameAccess!" );
871 0 : return xOrig->getByName( aName );
872 : }
873 :
874 :
875 : // virtual
876 0 : uno::Sequence< OUString > SAL_CALL HierarchyDataAccess::getElementNames()
877 : throw ( uno::RuntimeException, std::exception )
878 : {
879 : uno::Reference< container::XNameAccess > xOrig
880 0 : = ENSURE_ORIG_INTERFACE( container::XNameAccess, NA );
881 :
882 : OSL_ENSURE( xOrig.is(),
883 : "HierarchyDataAccess : Data source is not an XNameAccess!" );
884 0 : return xOrig->getElementNames();
885 : }
886 :
887 :
888 : // virtual
889 0 : sal_Bool SAL_CALL HierarchyDataAccess::hasByName( const OUString & aName )
890 : throw ( uno::RuntimeException, std::exception )
891 : {
892 : uno::Reference< container::XNameAccess > xOrig
893 0 : = ENSURE_ORIG_INTERFACE( container::XNameAccess, NA );
894 :
895 : OSL_ENSURE( xOrig.is(),
896 : "HierarchyDataAccess : Data source is not an XNameAccess!" );
897 0 : return xOrig->hasByName( aName );
898 : }
899 :
900 :
901 :
902 : // XElementAccess methods.
903 :
904 :
905 :
906 : // virtual
907 0 : uno::Type SAL_CALL HierarchyDataAccess::getElementType()
908 : throw ( uno::RuntimeException, std::exception )
909 : {
910 : uno::Reference< container::XElementAccess > xOrig
911 0 : = ENSURE_ORIG_INTERFACE( container::XElementAccess, EA );
912 :
913 : OSL_ENSURE( xOrig.is(),
914 : "HierarchyDataAccess : Data source is not an XElementAccess!" );
915 0 : return xOrig->getElementType();
916 : }
917 :
918 :
919 : // virtual
920 0 : sal_Bool SAL_CALL HierarchyDataAccess::hasElements()
921 : throw ( uno::RuntimeException, std::exception )
922 : {
923 : uno::Reference< container::XElementAccess > xOrig
924 0 : = ENSURE_ORIG_INTERFACE( container::XElementAccess, EA );
925 :
926 : OSL_ENSURE( xOrig.is(),
927 : "HierarchyDataAccess : Data source is not an XElementAccess!" );
928 0 : return xOrig->hasElements();
929 : }
930 :
931 :
932 :
933 : // XChangesNotifier methods.
934 :
935 :
936 :
937 : // virtual
938 0 : void SAL_CALL HierarchyDataAccess::addChangesListener(
939 : const uno::Reference< util::XChangesListener > & aListener )
940 : throw ( uno::RuntimeException, std::exception )
941 : {
942 : uno::Reference< util::XChangesNotifier > xOrig
943 0 : = ENSURE_ORIG_INTERFACE( util::XChangesNotifier, CN );
944 :
945 : OSL_ENSURE( xOrig.is(),
946 : "HierarchyDataAccess : Data source is not an XChangesNotifier!" );
947 0 : xOrig->addChangesListener( aListener );
948 0 : }
949 :
950 :
951 : // virtual
952 0 : void SAL_CALL HierarchyDataAccess::removeChangesListener(
953 : const uno::Reference< util::XChangesListener > & aListener )
954 : throw ( uno::RuntimeException, std::exception )
955 : {
956 : uno::Reference< util::XChangesNotifier > xOrig
957 0 : = ENSURE_ORIG_INTERFACE( util::XChangesNotifier, CN );
958 :
959 : OSL_ENSURE( xOrig.is(),
960 : "HierarchyDataAccess : Data source is not an XChangesNotifier!" );
961 0 : xOrig->removeChangesListener( aListener );
962 0 : }
963 :
964 :
965 :
966 : // XSingleServiceFactory methods.
967 :
968 :
969 :
970 : // virtual
971 0 : uno::Reference< uno::XInterface > SAL_CALL HierarchyDataAccess::createInstance()
972 : throw ( uno::Exception, uno::RuntimeException, std::exception )
973 : {
974 : uno::Reference< lang::XSingleServiceFactory > xOrig
975 0 : = ENSURE_ORIG_INTERFACE( lang::XSingleServiceFactory, SSF );
976 :
977 : OSL_ENSURE( xOrig.is(),
978 : "HierarchyDataAccess : Data source is not an XSingleServiceFactory!" );
979 0 : return xOrig->createInstance();
980 : }
981 :
982 :
983 : // virtual
984 : uno::Reference< uno::XInterface > SAL_CALL
985 0 : HierarchyDataAccess::createInstanceWithArguments(
986 : const uno::Sequence< uno::Any > & aArguments )
987 : throw ( uno::Exception, uno::RuntimeException, std::exception )
988 : {
989 : uno::Reference< lang::XSingleServiceFactory > xOrig
990 0 : = ENSURE_ORIG_INTERFACE( lang::XSingleServiceFactory, SSF );
991 :
992 : OSL_ENSURE( xOrig.is(),
993 : "HierarchyDataAccess : Data source is not an XSingleServiceFactory!" );
994 0 : return xOrig->createInstanceWithArguments( aArguments );
995 : }
996 :
997 :
998 :
999 : // XNameContainer methods.
1000 :
1001 :
1002 :
1003 : // virtual
1004 : void SAL_CALL
1005 0 : HierarchyDataAccess::insertByName( const OUString & aName,
1006 : const uno::Any & aElement )
1007 : throw ( lang::IllegalArgumentException,
1008 : container::ElementExistException,
1009 : lang::WrappedTargetException,
1010 : uno::RuntimeException, std::exception )
1011 : {
1012 : uno::Reference< container::XNameContainer > xOrig
1013 0 : = ENSURE_ORIG_INTERFACE( container::XNameContainer, NC );
1014 :
1015 : OSL_ENSURE( xOrig.is(),
1016 : "HierarchyDataAccess : Data source is not an XNameContainer!" );
1017 0 : xOrig->insertByName( aName, aElement );
1018 0 : }
1019 :
1020 :
1021 : // virtual
1022 : void SAL_CALL
1023 0 : HierarchyDataAccess::removeByName( const OUString & Name )
1024 : throw ( container::NoSuchElementException,
1025 : lang::WrappedTargetException,
1026 : uno::RuntimeException, std::exception )
1027 : {
1028 : uno::Reference< container::XNameContainer > xOrig
1029 0 : = ENSURE_ORIG_INTERFACE( container::XNameContainer, NC );
1030 :
1031 : OSL_ENSURE( xOrig.is(),
1032 : "HierarchyDataAccess : Data source is not an XNameContainer!" );
1033 0 : xOrig->removeByName( Name );
1034 0 : }
1035 :
1036 :
1037 :
1038 : // XNameReplace methods.
1039 :
1040 :
1041 :
1042 : // virtual
1043 0 : void SAL_CALL HierarchyDataAccess::replaceByName( const OUString & aName,
1044 : const uno::Any & aElement )
1045 : throw ( lang::IllegalArgumentException,
1046 : container::NoSuchElementException,
1047 : lang::WrappedTargetException,
1048 : uno::RuntimeException, std::exception )
1049 : {
1050 : uno::Reference< container::XNameReplace > xOrig
1051 0 : = ENSURE_ORIG_INTERFACE( container::XNameReplace, NR );
1052 :
1053 : OSL_ENSURE( xOrig.is(),
1054 : "HierarchyDataAccess : Data source is not an XNameReplace!" );
1055 0 : xOrig->replaceByName( aName, aElement );
1056 0 : }
1057 :
1058 :
1059 :
1060 : // XChangesBatch methods.
1061 :
1062 :
1063 :
1064 : // virtual
1065 0 : void SAL_CALL HierarchyDataAccess::commitChanges()
1066 : throw ( lang::WrappedTargetException, uno::RuntimeException, std::exception )
1067 : {
1068 : uno::Reference< util::XChangesBatch > xOrig
1069 0 : = ENSURE_ORIG_INTERFACE( util::XChangesBatch, CB );
1070 :
1071 : OSL_ENSURE( xOrig.is(),
1072 : "HierarchyDataAccess : Data source is not an XChangesBatch!" );
1073 0 : xOrig->commitChanges();
1074 0 : }
1075 :
1076 :
1077 : // virtual
1078 0 : sal_Bool SAL_CALL HierarchyDataAccess::hasPendingChanges()
1079 : throw ( uno::RuntimeException, std::exception )
1080 : {
1081 : uno::Reference< util::XChangesBatch > xOrig
1082 0 : = ENSURE_ORIG_INTERFACE( util::XChangesBatch, CB );
1083 :
1084 : OSL_ENSURE( xOrig.is(),
1085 : "HierarchyDataAccess : Data source is not an XChangesBatch!" );
1086 0 : return xOrig->hasPendingChanges();
1087 : }
1088 :
1089 :
1090 : // virtual
1091 : uno::Sequence< util::ElementChange > SAL_CALL
1092 0 : HierarchyDataAccess::getPendingChanges()
1093 : throw ( uno::RuntimeException, std::exception )
1094 : {
1095 : uno::Reference< util::XChangesBatch > xOrig
1096 0 : = ENSURE_ORIG_INTERFACE( util::XChangesBatch, CB );
1097 :
1098 : OSL_ENSURE( xOrig.is(),
1099 : "HierarchyDataAccess : Data source is not an XChangesBatch!" );
1100 0 : return xOrig->getPendingChanges();
1101 : }
1102 :
1103 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
