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 : #include <unotools/confignode.hxx>
22 : #include <unotools/configpaths.hxx>
23 : #include <tools/diagnose_ex.h>
24 : #include <osl/diagnose.h>
25 : #include <com/sun/star/container/XHierarchicalName.hpp>
26 : #include <com/sun/star/beans/PropertyValue.hpp>
27 : #include <com/sun/star/configuration/theDefaultProvider.hpp>
28 : #include <com/sun/star/lang/XSingleServiceFactory.hpp>
29 : #include <com/sun/star/lang/XComponent.hpp>
30 : #include <com/sun/star/util/XStringEscape.hpp>
31 : #include <com/sun/star/lang/XServiceInfo.hpp>
32 : #include <com/sun/star/container/XNamed.hpp>
33 : #include <comphelper/extract.hxx>
34 : #include <comphelper/componentcontext.hxx>
35 : #include <comphelper/namedvaluecollection.hxx>
36 : #include <rtl/string.hxx>
37 : #if OSL_DEBUG_LEVEL > 0
38 : #include <rtl/strbuf.hxx>
39 : #endif
40 :
41 : //........................................................................
42 : namespace utl
43 : {
44 : //........................................................................
45 :
46 : using namespace ::com::sun::star::uno;
47 : using namespace ::com::sun::star::lang;
48 : using namespace ::com::sun::star::util;
49 : using namespace ::com::sun::star::beans;
50 : using namespace ::com::sun::star::container;
51 : using namespace ::com::sun::star::configuration;
52 :
53 : //========================================================================
54 : //= OConfigurationNode
55 : //========================================================================
56 : //------------------------------------------------------------------------
57 34 : OConfigurationNode::OConfigurationNode(const Reference< XInterface >& _rxNode )
58 34 : :m_bEscapeNames(sal_False)
59 : {
60 : OSL_ENSURE(_rxNode.is(), "OConfigurationNode::OConfigurationNode: invalid node interface!");
61 34 : if (_rxNode.is())
62 : {
63 : // collect all interfaces necessary
64 34 : m_xHierarchyAccess = Reference< XHierarchicalNameAccess >(_rxNode, UNO_QUERY);
65 34 : m_xDirectAccess = Reference< XNameAccess >(_rxNode, UNO_QUERY);
66 :
67 : // reset _all_ interfaces if _one_ of them is not supported
68 34 : if (!m_xHierarchyAccess.is() || !m_xDirectAccess.is())
69 : {
70 0 : m_xHierarchyAccess = NULL;
71 0 : m_xDirectAccess = NULL;
72 : }
73 :
74 : // now for the non-critical interfaces
75 34 : m_xReplaceAccess = Reference< XNameReplace >(_rxNode, UNO_QUERY);
76 34 : m_xContainerAccess = Reference< XNameContainer >(_rxNode, UNO_QUERY);
77 : }
78 :
79 34 : Reference< XComponent > xConfigNodeComp(m_xDirectAccess, UNO_QUERY);
80 34 : if (xConfigNodeComp.is())
81 34 : startComponentListening(xConfigNodeComp);
82 :
83 34 : if (isValid())
84 34 : setEscape(isSetNode());
85 34 : }
86 :
87 : //------------------------------------------------------------------------
88 34 : OConfigurationNode::OConfigurationNode(const OConfigurationNode& _rSource)
89 : :OEventListenerAdapter()
90 : ,m_xHierarchyAccess(_rSource.m_xHierarchyAccess)
91 : ,m_xDirectAccess(_rSource.m_xDirectAccess)
92 : ,m_xReplaceAccess(_rSource.m_xReplaceAccess)
93 : ,m_xContainerAccess(_rSource.m_xContainerAccess)
94 : ,m_bEscapeNames(_rSource.m_bEscapeNames)
95 34 : ,m_sCompletePath(_rSource.m_sCompletePath)
96 : {
97 34 : Reference< XComponent > xConfigNodeComp(m_xDirectAccess, UNO_QUERY);
98 34 : if (xConfigNodeComp.is())
99 34 : startComponentListening(xConfigNodeComp);
100 34 : }
101 :
102 : //------------------------------------------------------------------------
103 0 : const OConfigurationNode& OConfigurationNode::operator=(const OConfigurationNode& _rSource)
104 : {
105 0 : stopAllComponentListening();
106 :
107 0 : m_xHierarchyAccess = _rSource.m_xHierarchyAccess;
108 0 : m_xDirectAccess = _rSource.m_xDirectAccess;
109 0 : m_xContainerAccess = _rSource.m_xContainerAccess;
110 0 : m_xReplaceAccess = _rSource.m_xReplaceAccess;
111 0 : m_bEscapeNames = _rSource.m_bEscapeNames;
112 0 : m_sCompletePath = _rSource.m_sCompletePath;
113 :
114 0 : Reference< XComponent > xConfigNodeComp(m_xDirectAccess, UNO_QUERY);
115 0 : if (xConfigNodeComp.is())
116 0 : startComponentListening(xConfigNodeComp);
117 :
118 0 : return *this;
119 : }
120 :
121 : //------------------------------------------------------------------------
122 0 : void OConfigurationNode::_disposing( const EventObject& _rSource )
123 : {
124 0 : Reference< XComponent > xDisposingSource(_rSource.Source, UNO_QUERY);
125 0 : Reference< XComponent > xConfigNodeComp(m_xDirectAccess, UNO_QUERY);
126 0 : if (xDisposingSource.get() == xConfigNodeComp.get())
127 0 : clear();
128 0 : }
129 :
130 : //------------------------------------------------------------------------
131 0 : ::rtl::OUString OConfigurationNode::getLocalName() const
132 : {
133 0 : ::rtl::OUString sLocalName;
134 : try
135 : {
136 0 : Reference< XNamed > xNamed( m_xDirectAccess, UNO_QUERY_THROW );
137 0 : sLocalName = xNamed->getName();
138 : }
139 0 : catch( const Exception& )
140 : {
141 : DBG_UNHANDLED_EXCEPTION();
142 : }
143 0 : return sLocalName;
144 : }
145 :
146 : //------------------------------------------------------------------------
147 0 : ::rtl::OUString OConfigurationNode::getNodePath() const
148 : {
149 0 : ::rtl::OUString sNodePath;
150 : try
151 : {
152 0 : Reference< XHierarchicalName > xNamed( m_xDirectAccess, UNO_QUERY_THROW );
153 0 : sNodePath = xNamed->getHierarchicalName();
154 : }
155 0 : catch( const Exception& )
156 : {
157 : DBG_UNHANDLED_EXCEPTION();
158 : }
159 0 : return sNodePath;
160 : }
161 :
162 : //------------------------------------------------------------------------
163 34 : ::rtl::OUString OConfigurationNode::normalizeName(const ::rtl::OUString& _rName, NAMEORIGIN _eOrigin) const
164 : {
165 34 : ::rtl::OUString sName(_rName);
166 34 : if (getEscape())
167 : {
168 0 : Reference< XStringEscape > xEscaper(m_xDirectAccess, UNO_QUERY);
169 0 : if (xEscaper.is() && !sName.isEmpty())
170 : {
171 : try
172 : {
173 0 : if (NO_CALLER == _eOrigin)
174 0 : sName = xEscaper->escapeString(sName);
175 : else
176 0 : sName = xEscaper->unescapeString(sName);
177 : }
178 0 : catch(Exception&)
179 : {
180 : DBG_UNHANDLED_EXCEPTION();
181 : }
182 0 : }
183 : }
184 34 : return sName;
185 : }
186 :
187 : //------------------------------------------------------------------------
188 0 : Sequence< ::rtl::OUString > OConfigurationNode::getNodeNames() const throw()
189 : {
190 : OSL_ENSURE(m_xDirectAccess.is(), "OConfigurationNode::getNodeNames: object is invalid!");
191 0 : Sequence< ::rtl::OUString > aReturn;
192 0 : if (m_xDirectAccess.is())
193 : {
194 : try
195 : {
196 0 : aReturn = m_xDirectAccess->getElementNames();
197 : // normalize the names
198 0 : ::rtl::OUString* pNames = aReturn.getArray();
199 0 : for (sal_Int32 i=0; i<aReturn.getLength(); ++i, ++pNames)
200 0 : *pNames = normalizeName(*pNames, NO_CONFIGURATION);
201 : }
202 0 : catch(Exception&)
203 : {
204 : OSL_FAIL("OConfigurationNode::getNodeNames: caught a generic exception!");
205 : }
206 : }
207 :
208 0 : return aReturn;
209 : }
210 :
211 : //------------------------------------------------------------------------
212 0 : sal_Bool OConfigurationNode::removeNode(const ::rtl::OUString& _rName) const throw()
213 : {
214 : OSL_ENSURE(m_xContainerAccess.is(), "OConfigurationNode::removeNode: object is invalid!");
215 0 : if (m_xContainerAccess.is())
216 : {
217 : try
218 : {
219 0 : ::rtl::OUString sName = normalizeName(_rName, NO_CALLER);
220 0 : m_xContainerAccess->removeByName(sName);
221 0 : return sal_True;
222 : }
223 0 : catch (NoSuchElementException&)
224 : {
225 : #if OSL_DEBUG_LEVEL > 0
226 : rtl::OStringBuffer aBuf( 256 );
227 : aBuf.append("OConfigurationNode::removeNode: there is no element named!");
228 : aBuf.append( rtl::OUStringToOString( _rName, RTL_TEXTENCODING_ASCII_US ) );
229 : aBuf.append( "!" );
230 : OSL_FAIL(aBuf.getStr());
231 : #endif
232 : }
233 0 : catch (WrappedTargetException&)
234 : {
235 : OSL_FAIL("OConfigurationNode::removeNode: caught a WrappedTargetException!");
236 : }
237 0 : catch(Exception&)
238 : {
239 : OSL_FAIL("OConfigurationNode::removeNode: caught a generic exception!");
240 : }
241 : }
242 0 : return sal_False;
243 : }
244 : //------------------------------------------------------------------------
245 0 : OConfigurationNode OConfigurationNode::insertNode(const ::rtl::OUString& _rName,const Reference< XInterface >& _xNode) const throw()
246 : {
247 0 : if(_xNode.is())
248 : {
249 : try
250 : {
251 0 : ::rtl::OUString sName = normalizeName(_rName, NO_CALLER);
252 0 : m_xContainerAccess->insertByName(sName, makeAny(_xNode));
253 : // if we're here, all was ok ...
254 0 : return OConfigurationNode( _xNode );
255 : }
256 0 : catch(const Exception&)
257 : {
258 : DBG_UNHANDLED_EXCEPTION();
259 : }
260 :
261 : // dispose the child if it has already been created, but could not be inserted
262 0 : Reference< XComponent > xChildComp(_xNode, UNO_QUERY);
263 0 : if (xChildComp.is())
264 0 : try { xChildComp->dispose(); } catch(Exception&) { }
265 : }
266 :
267 0 : return OConfigurationNode();
268 : }
269 : //------------------------------------------------------------------------
270 0 : OConfigurationNode OConfigurationNode::createNode(const ::rtl::OUString& _rName) const throw()
271 : {
272 0 : Reference< XSingleServiceFactory > xChildFactory(m_xContainerAccess, UNO_QUERY);
273 : OSL_ENSURE(xChildFactory.is(), "OConfigurationNode::createNode: object is invalid or read-only!");
274 :
275 0 : if (xChildFactory.is()) // implies m_xContainerAccess.is()
276 : {
277 0 : Reference< XInterface > xNewChild;
278 : try
279 : {
280 0 : xNewChild = xChildFactory->createInstance();
281 : }
282 0 : catch(const Exception&)
283 : {
284 : DBG_UNHANDLED_EXCEPTION();
285 : }
286 0 : return insertNode(_rName,xNewChild);
287 : }
288 :
289 0 : return OConfigurationNode();
290 : }
291 :
292 : //------------------------------------------------------------------------
293 0 : OConfigurationNode OConfigurationNode::openNode(const ::rtl::OUString& _rPath) const throw()
294 : {
295 : OSL_ENSURE(m_xDirectAccess.is(), "OConfigurationNode::openNode: object is invalid!");
296 : OSL_ENSURE(m_xHierarchyAccess.is(), "OConfigurationNode::openNode: object is invalid!");
297 : try
298 : {
299 0 : ::rtl::OUString sNormalized = normalizeName(_rPath, NO_CALLER);
300 :
301 0 : Reference< XInterface > xNode;
302 0 : if (m_xDirectAccess.is() && m_xDirectAccess->hasByName(sNormalized))
303 : {
304 0 : if (!::cppu::extractInterface(xNode, m_xDirectAccess->getByName(sNormalized)))
305 : OSL_FAIL("OConfigurationNode::openNode: could not open the node!");
306 : }
307 0 : else if (m_xHierarchyAccess.is())
308 : {
309 0 : if (!::cppu::extractInterface(xNode, m_xHierarchyAccess->getByHierarchicalName(_rPath)))
310 : OSL_FAIL("OConfigurationNode::openNode: could not open the node!");
311 : }
312 0 : if (xNode.is())
313 0 : return OConfigurationNode( xNode );
314 : }
315 0 : catch(const NoSuchElementException&)
316 : {
317 : #if OSL_DEBUG_LEVEL > 0
318 : rtl::OStringBuffer aBuf( 256 );
319 : aBuf.append("OConfigurationNode::openNode: there is no element named ");
320 : aBuf.append( rtl::OUStringToOString( _rPath, RTL_TEXTENCODING_ASCII_US ) );
321 : aBuf.append("!");
322 : OSL_FAIL(aBuf.getStr());
323 : #endif
324 : }
325 0 : catch(Exception&)
326 : {
327 : OSL_FAIL("OConfigurationNode::openNode: caught an exception while retrieving the node!");
328 : }
329 0 : return OConfigurationNode();
330 : }
331 :
332 : //------------------------------------------------------------------------
333 34 : void OConfigurationNode::setEscape(sal_Bool _bEnable)
334 : {
335 34 : m_bEscapeNames = _bEnable && Reference< XStringEscape >::query(m_xDirectAccess).is();
336 34 : }
337 :
338 : //------------------------------------------------------------------------
339 34 : sal_Bool OConfigurationNode::isSetNode() const
340 : {
341 34 : sal_Bool bIsSet = sal_False;
342 34 : Reference< XServiceInfo > xSI(m_xHierarchyAccess, UNO_QUERY);
343 34 : if (xSI.is())
344 : {
345 34 : try { bIsSet = xSI->supportsService(::rtl::OUString("com.sun.star.configuration.SetAccess")); }
346 0 : catch(Exception&) { }
347 : }
348 34 : return bIsSet;
349 : }
350 :
351 0 : sal_Bool OConfigurationNode::hasByHierarchicalName( const ::rtl::OUString& _rName ) const throw()
352 : {
353 : OSL_ENSURE( m_xHierarchyAccess.is(), "OConfigurationNode::hasByHierarchicalName: no hierarchy access!" );
354 : try
355 : {
356 0 : if ( m_xHierarchyAccess.is() )
357 : {
358 0 : ::rtl::OUString sName = normalizeName( _rName, NO_CALLER );
359 0 : return m_xHierarchyAccess->hasByHierarchicalName( sName );
360 : }
361 : }
362 0 : catch(Exception&)
363 : {
364 : }
365 0 : return sal_False;
366 : }
367 :
368 : //------------------------------------------------------------------------
369 0 : sal_Bool OConfigurationNode::hasByName(const ::rtl::OUString& _rName) const throw()
370 : {
371 : OSL_ENSURE(m_xDirectAccess.is(), "OConfigurationNode::hasByName: object is invalid!");
372 : try
373 : {
374 0 : ::rtl::OUString sName = normalizeName(_rName, NO_CALLER);
375 0 : if (m_xDirectAccess.is())
376 0 : return m_xDirectAccess->hasByName(sName);
377 : }
378 0 : catch(Exception&)
379 : {
380 : }
381 0 : return sal_False;
382 : }
383 :
384 : //------------------------------------------------------------------------
385 0 : sal_Bool OConfigurationNode::setNodeValue(const ::rtl::OUString& _rPath, const Any& _rValue) const throw()
386 : {
387 0 : sal_Bool bResult = false;
388 :
389 : OSL_ENSURE(m_xReplaceAccess.is(), "OConfigurationNode::setNodeValue: object is invalid!");
390 0 : if (m_xReplaceAccess.is())
391 : {
392 : try
393 : {
394 : // check if _rPath is a level-1 path
395 0 : ::rtl::OUString sNormalizedName = normalizeName(_rPath, NO_CALLER);
396 0 : if (m_xReplaceAccess->hasByName(sNormalizedName))
397 : {
398 0 : m_xReplaceAccess->replaceByName(sNormalizedName, _rValue);
399 0 : bResult = true;
400 : }
401 :
402 : // check if the name refers to a indirect descendant
403 0 : else if (m_xHierarchyAccess.is() && m_xHierarchyAccess->hasByHierarchicalName(_rPath))
404 : {
405 : OSL_ASSERT(!_rPath.isEmpty());
406 :
407 0 : ::rtl::OUString sParentPath, sLocalName;
408 :
409 0 : if ( splitLastFromConfigurationPath(_rPath, sParentPath, sLocalName) )
410 : {
411 0 : OConfigurationNode aParentAccess = openNode(sParentPath);
412 0 : if (aParentAccess.isValid())
413 0 : bResult = aParentAccess.setNodeValue(sLocalName, _rValue);
414 : }
415 : else
416 : {
417 0 : m_xReplaceAccess->replaceByName(sLocalName, _rValue);
418 0 : bResult = true;
419 0 : }
420 0 : }
421 :
422 : }
423 0 : catch(IllegalArgumentException&)
424 : {
425 : OSL_FAIL("OConfigurationNode::setNodeValue: could not replace the value: caught an IllegalArgumentException!");
426 : }
427 0 : catch(NoSuchElementException&)
428 : {
429 : OSL_FAIL("OConfigurationNode::setNodeValue: could not replace the value: caught a NoSuchElementException!");
430 : }
431 0 : catch(WrappedTargetException&)
432 : {
433 : OSL_FAIL("OConfigurationNode::setNodeValue: could not replace the value: caught a WrappedTargetException!");
434 : }
435 0 : catch(Exception&)
436 : {
437 : OSL_FAIL("OConfigurationNode::setNodeValue: could not replace the value: caught a generic Exception!");
438 : }
439 :
440 :
441 : }
442 0 : return bResult;
443 : }
444 :
445 : //------------------------------------------------------------------------
446 34 : Any OConfigurationNode::getNodeValue(const ::rtl::OUString& _rPath) const throw()
447 : {
448 : OSL_ENSURE(m_xDirectAccess.is(), "OConfigurationNode::hasByName: object is invalid!");
449 : OSL_ENSURE(m_xHierarchyAccess.is(), "OConfigurationNode::hasByName: object is invalid!");
450 34 : Any aReturn;
451 : try
452 : {
453 34 : ::rtl::OUString sNormalizedPath = normalizeName(_rPath, NO_CALLER);
454 34 : if (m_xDirectAccess.is() && m_xDirectAccess->hasByName(sNormalizedPath) )
455 : {
456 34 : aReturn = m_xDirectAccess->getByName(sNormalizedPath);
457 : }
458 0 : else if (m_xHierarchyAccess.is())
459 : {
460 0 : aReturn = m_xHierarchyAccess->getByHierarchicalName(_rPath);
461 34 : }
462 : }
463 0 : catch(const NoSuchElementException&)
464 : {
465 : DBG_UNHANDLED_EXCEPTION();
466 : }
467 34 : return aReturn;
468 : }
469 :
470 : //------------------------------------------------------------------------
471 0 : void OConfigurationNode::clear() throw()
472 : {
473 0 : m_xHierarchyAccess.clear();
474 0 : m_xDirectAccess.clear();
475 0 : m_xReplaceAccess.clear();
476 0 : m_xContainerAccess.clear();
477 0 : }
478 :
479 : //========================================================================
480 : //= helper
481 : //========================================================================
482 : namespace
483 : {
484 : //--------------------------------------------------------------------
485 2 : Reference< XMultiServiceFactory > lcl_getConfigProvider( const ::comphelper::ComponentContext& i_rContext )
486 : {
487 : try
488 : {
489 2 : Reference< XMultiServiceFactory > xProvider = theDefaultProvider::get( i_rContext.getUNOContext() );
490 2 : return xProvider;
491 : }
492 0 : catch ( const Exception& )
493 : {
494 : DBG_UNHANDLED_EXCEPTION();
495 : }
496 0 : return NULL;
497 : }
498 :
499 : //--------------------------------------------------------------------
500 34 : Reference< XInterface > lcl_createConfigurationRoot( const Reference< XMultiServiceFactory >& i_rxConfigProvider,
501 : const ::rtl::OUString& i_rNodePath, const bool i_bUpdatable, const sal_Int32 i_nDepth, const bool i_bLazyWrite )
502 : {
503 34 : ENSURE_OR_RETURN( i_rxConfigProvider.is(), "invalid provider", NULL );
504 : try
505 : {
506 34 : ::comphelper::NamedValueCollection aArgs;
507 34 : aArgs.put( "nodepath", i_rNodePath );
508 34 : aArgs.put( "lazywrite", i_bLazyWrite );
509 34 : aArgs.put( "depth", i_nDepth );
510 :
511 : ::rtl::OUString sAccessService( i_bUpdatable ?
512 : ::rtl::OUString( "com.sun.star.configuration.ConfigurationUpdateAccess" ) :
513 34 : ::rtl::OUString( "com.sun.star.configuration.ConfigurationAccess" ));
514 :
515 : Reference< XInterface > xRoot(
516 34 : i_rxConfigProvider->createInstanceWithArguments( sAccessService, aArgs.getWrappedPropertyValues() ),
517 : UNO_SET_THROW
518 34 : );
519 34 : return xRoot;
520 : }
521 0 : catch ( const Exception& )
522 : {
523 : DBG_UNHANDLED_EXCEPTION();
524 : }
525 0 : return NULL;
526 : }
527 : }
528 :
529 : //------------------------------------------------------------------------
530 34 : OConfigurationTreeRoot::OConfigurationTreeRoot( const Reference< XInterface >& _rxRootNode )
531 : :OConfigurationNode( _rxRootNode )
532 34 : ,m_xCommitter( _rxRootNode, UNO_QUERY )
533 : {
534 34 : }
535 :
536 : //------------------------------------------------------------------------
537 0 : OConfigurationTreeRoot::OConfigurationTreeRoot( const ::comphelper::ComponentContext& i_rContext, const ::rtl::OUString& i_rNodePath, const bool i_bUpdatable )
538 : :OConfigurationNode( lcl_createConfigurationRoot( lcl_getConfigProvider( i_rContext.getLegacyServiceFactory() ),
539 : i_rNodePath, i_bUpdatable, -1, false ).get() )
540 0 : ,m_xCommitter()
541 : {
542 0 : if ( i_bUpdatable )
543 : {
544 0 : m_xCommitter.set( getUNONode(), UNO_QUERY );
545 : OSL_ENSURE( m_xCommitter.is(), "OConfigurationTreeRoot::OConfigurationTreeRoot: could not create an updatable node!" );
546 : }
547 0 : }
548 :
549 : //------------------------------------------------------------------------
550 0 : void OConfigurationTreeRoot::clear() throw()
551 : {
552 0 : OConfigurationNode::clear();
553 0 : m_xCommitter.clear();
554 0 : }
555 :
556 : //------------------------------------------------------------------------
557 0 : sal_Bool OConfigurationTreeRoot::commit() const throw()
558 : {
559 : OSL_ENSURE(isValid(), "OConfigurationTreeRoot::commit: object is invalid!");
560 0 : if (!isValid())
561 0 : return sal_False;
562 : OSL_ENSURE(m_xCommitter.is(), "OConfigurationTreeRoot::commit: I'm a readonly node!");
563 0 : if (!m_xCommitter.is())
564 0 : return sal_False;
565 :
566 : try
567 : {
568 0 : m_xCommitter->commitChanges();
569 0 : return sal_True;
570 : }
571 0 : catch(const Exception&)
572 : {
573 : DBG_UNHANDLED_EXCEPTION();
574 : }
575 0 : return sal_False;
576 : }
577 :
578 : //------------------------------------------------------------------------
579 34 : OConfigurationTreeRoot OConfigurationTreeRoot::createWithProvider(const Reference< XMultiServiceFactory >& _rxConfProvider, const ::rtl::OUString& _rPath, sal_Int32 _nDepth, CREATION_MODE _eMode, sal_Bool _bLazyWrite)
580 : {
581 : Reference< XInterface > xRoot( lcl_createConfigurationRoot(
582 34 : _rxConfProvider, _rPath, _eMode != CM_READONLY, _nDepth, _bLazyWrite ) );
583 34 : if ( xRoot.is() )
584 34 : return OConfigurationTreeRoot( xRoot );
585 0 : return OConfigurationTreeRoot();
586 : }
587 :
588 : //------------------------------------------------------------------------
589 2 : OConfigurationTreeRoot OConfigurationTreeRoot::createWithServiceFactory( const Reference< XMultiServiceFactory >& _rxORB, const ::rtl::OUString& _rPath, sal_Int32 _nDepth, CREATION_MODE _eMode, sal_Bool _bLazyWrite )
590 : {
591 2 : return createWithProvider( lcl_getConfigProvider( _rxORB ), _rPath, _nDepth, _eMode, _bLazyWrite );
592 : }
593 :
594 : //------------------------------------------------------------------------
595 32 : OConfigurationTreeRoot OConfigurationTreeRoot::tryCreateWithComponentContext( const Reference< XComponentContext >& rxContext,
596 : const ::rtl::OUString& _rPath, sal_Int32 _nDepth , CREATION_MODE _eMode , sal_Bool _bLazyWrite )
597 : {
598 : OSL_ENSURE( rxContext.is(), "OConfigurationTreeRoot::tryCreateWithComponentContext: invalid XComponentContext!" );
599 : try
600 : {
601 32 : Reference< XMultiServiceFactory > xConfigFactory = theDefaultProvider::get( rxContext );
602 32 : return createWithProvider( xConfigFactory, _rPath, _nDepth, _eMode, _bLazyWrite );
603 : }
604 0 : catch(const Exception&)
605 : {
606 : // silence this, 'cause the contract of this method states "no assertions"
607 : }
608 0 : return OConfigurationTreeRoot();
609 : }
610 :
611 : //........................................................................
612 : } // namespace utl
613 : //........................................................................
614 :
615 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
