LCOV - code coverage report
Current view: top level - unotools/source/config - confignode.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 139 224 62.1 %
Date: 2015-06-13 12:38:46 Functions: 23 28 82.1 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.11