unotools/source/config/confignode.cxx

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