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

Generated by: LCOV version 1.10