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