LCOV - code coverage report
Current view: top level - ucb/source/ucp/hierarchy - hierarchydata.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 209 450 46.4 %
Date: 2014-11-03 Functions: 14 16 87.5 %
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             :  - HierarchyEntry::move
      26             :    --> Rewrite to use XNamed ( once this is supported by config db api ).
      27             : 
      28             :  *************************************************************************/
      29             : #include "hierarchydata.hxx"
      30             : 
      31             : #include <vector>
      32             : #include <osl/diagnose.h>
      33             : #include <rtl/ustrbuf.hxx>
      34             : #include <com/sun/star/beans/PropertyValue.hpp>
      35             : #include <com/sun/star/container/XHierarchicalNameAccess.hpp>
      36             : #include <com/sun/star/container/XNameContainer.hpp>
      37             : #include <com/sun/star/container/XNameReplace.hpp>
      38             : #include <com/sun/star/util/XChangesBatch.hpp>
      39             : #include <com/sun/star/util/XOfficeInstallationDirectories.hpp>
      40             : #include "hierarchyprovider.hxx"
      41             : #include "hierarchyuri.hxx"
      42             : 
      43             : using namespace com::sun::star;
      44             : 
      45             : namespace hierarchy_ucp
      46             : {
      47             : 
      48             : 
      49           8 : struct HierarchyEntry::iterator_Impl
      50             : {
      51             :     HierarchyEntryData                                     entry;
      52             :     uno::Reference< container::XHierarchicalNameAccess >   dir;
      53             :     uno::Reference< util::XOfficeInstallationDirectories > officeDirs;
      54             :     uno::Sequence< OUString>                          names;
      55             :     sal_Int32                                              pos;
      56           8 :     iterator_Impl()
      57           8 :     : officeDirs( 0 ), pos( -1 /* before first */ ) {};
      58             : };
      59             : 
      60             : 
      61         432 : void makeXMLName( const OUString & rIn, OUStringBuffer & rBuffer  )
      62             : {
      63         432 :     sal_Int32 nCount = rIn.getLength();
      64        5652 :     for ( sal_Int32 n = 0; n < nCount; ++n )
      65             :     {
      66        5220 :         const sal_Unicode c = rIn[ n ];
      67        5220 :         switch ( c )
      68             :         {
      69             :             case '&':
      70           0 :                 rBuffer.appendAscii( "&amp;" );
      71           0 :                 break;
      72             : 
      73             :             case '"':
      74           0 :                 rBuffer.appendAscii( "&quot;" );
      75           0 :                 break;
      76             : 
      77             :             case '\'':
      78           0 :                 rBuffer.appendAscii( "&apos;" );
      79           0 :                 break;
      80             : 
      81             :             case '<':
      82           0 :                 rBuffer.appendAscii( "&lt;" );
      83           0 :                 break;
      84             : 
      85             :             case '>':
      86           0 :                 rBuffer.appendAscii( "&gt;" );
      87           0 :                 break;
      88             : 
      89             :             default:
      90        5220 :                 rBuffer.append( c );
      91        5220 :                 break;
      92             :         }
      93             :     }
      94         432 : }
      95             : 
      96             : 
      97             : 
      98             : 
      99             : // HierarchyEntry Implementation.
     100             : 
     101             : 
     102             : 
     103             : 
     104             : #define READ_SERVICE_NAME      "com.sun.star.ucb.HierarchyDataReadAccess"
     105             : #define READWRITE_SERVICE_NAME "com.sun.star.ucb.HierarchyDataReadWriteAccess"
     106             : 
     107             : // describe path of cfg entry
     108             : #define CFGPROPERTY_NODEPATH    "nodepath"
     109             : 
     110             : 
     111         118 : HierarchyEntry::HierarchyEntry(
     112             :                 const uno::Reference< uno::XComponentContext >& rxContext,
     113             :                 HierarchyContentProvider* pProvider,
     114             :                 const OUString& rURL )
     115             : : m_xContext( rxContext ),
     116             :   m_xOfficeInstDirs( pProvider->getOfficeInstallationDirectories() ),
     117         118 :   m_bTriedToGetRootReadAccess( false )
     118             : {
     119         118 :     HierarchyUri aUri( rURL );
     120         118 :     m_aServiceSpecifier = aUri.getService();
     121             : 
     122             :     m_xConfigProvider
     123         118 :         = pProvider->getConfigProvider( m_aServiceSpecifier );
     124             :     m_xRootReadAccess
     125         118 :         = pProvider->getRootConfigReadNameAccess( m_aServiceSpecifier );
     126             : 
     127             :     // Note: do not init m_aPath in init list. createPathFromHierarchyURL
     128             :     //       needs m_xContext and m_aMutex.
     129         118 :     m_aPath = createPathFromHierarchyURL( aUri );
     130             : 
     131             :     // Extract language independent name from URL.
     132         118 :     sal_Int32 nPos = rURL.lastIndexOf( '/' );
     133         118 :     if ( nPos > HIERARCHY_URL_SCHEME_LENGTH )
     134         118 :         m_aName = rURL.copy( nPos + 1 );
     135             :     else
     136         118 :         OSL_FAIL( "HierarchyEntry - Invalid URL!" );
     137         118 : }
     138             : 
     139             : 
     140          28 : bool HierarchyEntry::hasData()
     141             : {
     142          28 :     osl::Guard< osl::Mutex > aGuard( m_aMutex );
     143             :     uno::Reference< container::XHierarchicalNameAccess > xRootReadAccess
     144          56 :         = getRootReadAccess();
     145             : 
     146             :     OSL_ENSURE( xRootReadAccess.is(), "HierarchyEntry::hasData - No root!" );
     147             : 
     148          28 :     if ( xRootReadAccess.is() )
     149          28 :         return xRootReadAccess->hasByHierarchicalName( m_aPath );
     150             : 
     151          28 :     return false;
     152             : }
     153             : 
     154             : 
     155          48 : bool HierarchyEntry::getData( HierarchyEntryData& rData )
     156             : {
     157             :     try
     158             :     {
     159          48 :         osl::Guard< osl::Mutex > aGuard( m_aMutex );
     160             : 
     161             :         uno::Reference< container::XHierarchicalNameAccess > xRootReadAccess
     162          48 :             = getRootReadAccess();
     163             : 
     164             :         OSL_ENSURE( xRootReadAccess.is(),
     165             :                     "HierarchyEntry::getData - No root!" );
     166             : 
     167          48 :         if ( xRootReadAccess.is() )
     168             :         {
     169          48 :             OUString aTitlePath = m_aPath;
     170          48 :             aTitlePath += "/Title";
     171             : 
     172             :             // Note: Avoid NoSuchElementExceptions, because exceptions are
     173             :             //       relatively 'expensive'. Checking for availability of
     174             :             //       title value is sufficient here, because if it is
     175             :             //       there, the other values will be available too.
     176          48 :             if ( !xRootReadAccess->hasByHierarchicalName( aTitlePath ) )
     177          44 :                 return false;
     178             : 
     179           8 :             OUString aValue;
     180             : 
     181             :             // Get Title value.
     182          12 :             if ( !( xRootReadAccess->getByHierarchicalName( aTitlePath )
     183           8 :                     >>= aValue ) )
     184             :             {
     185             :                 OSL_FAIL( "HierarchyEntry::getData - "
     186             :                             "Got no Title value!" );
     187           0 :                 return false;
     188             :             }
     189             : 
     190           4 :             rData.setTitle( aValue );
     191             : 
     192             :             // Get TargetURL value.
     193           8 :             OUString aTargetURLPath = m_aPath;
     194           4 :             aTargetURLPath += "/TargetURL";
     195          12 :             if ( !( xRootReadAccess->getByHierarchicalName( aTargetURLPath )
     196           8 :                     >>= aValue ) )
     197             :             {
     198             :                 OSL_FAIL( "HierarchyEntry::getData - "
     199             :                             "Got no TargetURL value!" );
     200           0 :                 return false;
     201             :             }
     202             : 
     203             :             // TargetURL property may contain a reference to the Office
     204             :             // installation directory. To ensure a reloctable office
     205             :             // installation, the path to the office installtion directory must
     206             :             // never be stored directly. A placeholder is used instead. Replace
     207             :             // it by actual installation directory.
     208           4 :             if ( m_xOfficeInstDirs.is() &&  !aValue.isEmpty()  )
     209           0 :                 aValue = m_xOfficeInstDirs->makeAbsoluteURL( aValue );
     210           4 :             rData.setTargetURL( aValue );
     211             : 
     212           8 :             OUString aTypePath = m_aPath;
     213           4 :             aTypePath += "/Type";
     214           4 :             if ( xRootReadAccess->hasByHierarchicalName( aTypePath ) )
     215             :             {
     216             :                 // Might not be present since it was introduced long after
     217             :                 // Title and TargetURL (#82433#)... So not getting it is
     218             :                 // not an error.
     219             : 
     220             :                 // Get Type value.
     221           4 :                 sal_Int32 nType = 0;
     222          12 :                 if ( xRootReadAccess->getByHierarchicalName( aTypePath )
     223           8 :                      >>= nType )
     224             :                 {
     225           4 :                     if ( nType == 0 )
     226             :                     {
     227           0 :                         rData.setType( HierarchyEntryData::LINK );
     228             :                     }
     229           4 :                     else if ( nType == 1 )
     230             :                     {
     231           4 :                         rData.setType( HierarchyEntryData::FOLDER );
     232             :                     }
     233             :                     else
     234             :                     {
     235             :                         OSL_FAIL( "HierarchyEntry::getData - "
     236             :                                     "Unknown Type value!" );
     237           0 :                         return false;
     238             :                     }
     239             :                 }
     240             :             }
     241             : 
     242           4 :             rData.setName( m_aName );
     243          52 :             return true;
     244           0 :         }
     245             :     }
     246           0 :     catch ( uno::RuntimeException const & )
     247             :     {
     248           0 :         throw;
     249             :     }
     250           0 :     catch ( container::NoSuchElementException const & )
     251             :     {
     252             :         // getByHierarchicalName
     253             : 
     254             :         OSL_FAIL( "HierarchyEntry::getData - caught NoSuchElementException!" );
     255             :     }
     256           0 :     return false;
     257             : }
     258             : 
     259             : 
     260          34 : bool HierarchyEntry::setData(
     261             :                     const HierarchyEntryData& rData, bool bCreate )
     262             : {
     263             :     try
     264             :     {
     265          34 :         osl::Guard< osl::Mutex > aGuard( m_aMutex );
     266             : 
     267          34 :         if ( !m_xConfigProvider.is() )
     268           0 :             m_xConfigProvider = uno::Reference< lang::XMultiServiceFactory >(
     269           0 :                 m_xContext->getServiceManager()->createInstanceWithContext(m_aServiceSpecifier, m_xContext),
     270           0 :                 uno::UNO_QUERY );
     271             : 
     272          34 :         if ( m_xConfigProvider.is() )
     273             :         {
     274             :             // Create parent's key. It must exist!
     275             : 
     276          34 :             OUString aParentPath;
     277          34 :             bool bRoot = true;
     278             : 
     279          34 :             sal_Int32 nPos = m_aPath.lastIndexOf( '/' );
     280          34 :             if ( nPos != -1 )
     281             :             {
     282             :                 // Skip "/Children" segment of the path, too.
     283          32 :                 nPos = m_aPath.lastIndexOf( '/', nPos - 1 );
     284             : 
     285             :                 OSL_ENSURE( nPos != -1,
     286             :                             "HierarchyEntry::setData - Wrong path!" );
     287             : 
     288          32 :                 aParentPath += m_aPath.copy( 0, nPos );
     289          32 :                 bRoot = false;
     290             :             }
     291             : 
     292          34 :             uno::Sequence< uno::Any > aArguments( 1 );
     293          34 :             beans::PropertyValue      aProperty;
     294             : 
     295          34 :             aProperty.Name    = OUString( CFGPROPERTY_NODEPATH  );
     296          34 :             aProperty.Value <<= aParentPath;
     297          34 :             aArguments[ 0 ] <<= aProperty;
     298             : 
     299             :             uno::Reference< util::XChangesBatch > xBatch(
     300          34 :                     m_xConfigProvider->createInstanceWithArguments(
     301             :                         OUString( READWRITE_SERVICE_NAME  ),
     302          34 :                         aArguments ),
     303          34 :                     uno::UNO_QUERY );
     304             : 
     305             :             OSL_ENSURE( xBatch.is(),
     306             :                         "HierarchyEntry::setData - No batch!" );
     307             : 
     308             :             uno::Reference< container::XNameAccess > xParentNameAccess(
     309          34 :                 xBatch, uno::UNO_QUERY );
     310             : 
     311             :             OSL_ENSURE( xParentNameAccess.is(),
     312             :                         "HierarchyEntry::setData - No name access!" );
     313             : 
     314          34 :             if ( xBatch.is() && xParentNameAccess.is() )
     315             :             {
     316             :                 // Try to create own key. It must not exist!
     317             : 
     318          34 :                 bool bExists = true;
     319          34 :                 uno::Any aMyKey;
     320             : 
     321             :                 try
     322             :                 {
     323          34 :                     uno::Reference< container::XNameAccess > xNameAccess;
     324             : 
     325          34 :                     if ( bRoot )
     326             :                     {
     327           2 :                         xNameAccess = xParentNameAccess;
     328             :                     }
     329             :                     else
     330             :                     {
     331          32 :                         xParentNameAccess->getByName(
     332          32 :                             OUString("Children") )
     333          32 :                                 >>= xNameAccess;
     334             :                     }
     335             : 
     336          34 :                     if ( xNameAccess->hasByName( m_aName ) )
     337           6 :                         aMyKey = xNameAccess->getByName( m_aName );
     338             :                     else
     339          28 :                         bExists = false;
     340             :                 }
     341           0 :                 catch ( container::NoSuchElementException const & )
     342             :                 {
     343           0 :                     bExists = false;
     344             :                 }
     345             : 
     346          34 :                 uno::Reference< container::XNameReplace >   xNameReplace;
     347          34 :                 uno::Reference< container::XNameContainer > xContainer;
     348             : 
     349          34 :                 if ( bExists )
     350             :                 {
     351             :                     // Key exists. Replace values.
     352             : 
     353           6 :                     aMyKey >>= xNameReplace;
     354             : 
     355             :                     OSL_ENSURE( xNameReplace.is(),
     356             :                                 "HierarchyEntry::setData - No name replace!" );
     357             :                 }
     358             :                 else
     359             :                 {
     360          28 :                     if ( !bCreate )
     361           0 :                         return true;
     362             : 
     363             :                     // Key does not exist. Create / fill / insert it.
     364             : 
     365          28 :                     uno::Reference< lang::XSingleServiceFactory > xFac;
     366             : 
     367          28 :                     if ( bRoot )
     368             :                     {
     369             :                         // Special handling for children of root,
     370             :                         // which is not an entry. It's only a set
     371             :                         // of entries.
     372           4 :                         xFac = uno::Reference< lang::XSingleServiceFactory >(
     373           2 :                             xParentNameAccess, uno::UNO_QUERY );
     374             :                     }
     375             :                     else
     376             :                     {
     377             :                         // Append new entry to parents child list,
     378             :                         // which is a set of entries.
     379          26 :                         xParentNameAccess->getByName(
     380          26 :                                         OUString( "Children" ) ) >>= xFac;
     381             :                     }
     382             : 
     383             :                     OSL_ENSURE( xFac.is(),
     384             :                                 "HierarchyEntry::setData - No factory!" );
     385             : 
     386          28 :                     if ( xFac.is() )
     387             :                     {
     388             :                         xNameReplace
     389          56 :                             = uno::Reference< container::XNameReplace >(
     390          56 :                                 xFac->createInstance(), uno::UNO_QUERY );
     391             : 
     392             :                         OSL_ENSURE( xNameReplace.is(),
     393             :                                 "HierarchyEntry::setData - No name replace!" );
     394             : 
     395          28 :                         if ( xNameReplace.is() )
     396             :                         {
     397             :                             xContainer
     398          56 :                                 = uno::Reference< container::XNameContainer >(
     399          28 :                                     xFac, uno::UNO_QUERY );
     400             : 
     401             :                             OSL_ENSURE( xContainer.is(),
     402             :                                 "HierarchyEntry::setData - No container!" );
     403             :                         }
     404          28 :                     }
     405             :                 }
     406             : 
     407          34 :                 if ( xNameReplace.is() )
     408             :                 {
     409             :                     // Set Title value.
     410          34 :                     xNameReplace->replaceByName(
     411             :                         OUString("Title"),
     412          34 :                         uno::makeAny( rData.getTitle() ) );
     413             : 
     414             :                     // Set TargetURL value.
     415             : 
     416             :                     // TargetURL property may contain a reference to the Office
     417             :                     // installation directory. To ensure a reloctable office
     418             :                     // installation, the path to the office installtion
     419             :                     // directory must never be stored directly. Use a
     420             :                     // placeholder instead.
     421          34 :                     OUString aValue( rData.getTargetURL() );
     422          34 :                     if ( m_xOfficeInstDirs.is() &&  !aValue.isEmpty() )
     423             :                         aValue
     424          20 :                             = m_xOfficeInstDirs->makeRelocatableURL( aValue );
     425             : 
     426          34 :                     xNameReplace->replaceByName(
     427             :                         OUString("TargetURL"),
     428          34 :                         uno::makeAny( aValue ) );
     429             : 
     430             :                     // Set Type value.
     431             :                     sal_Int32 nType
     432          34 :                         = rData.getType() == HierarchyEntryData::LINK ? 0 : 1;
     433          34 :                     xNameReplace->replaceByName(
     434             :                         OUString("Type"),
     435          34 :                         uno::makeAny( nType ) );
     436             : 
     437          34 :                     if ( xContainer.is() )
     438          28 :                         xContainer->insertByName(
     439          28 :                             m_aName, uno::makeAny( xNameReplace ) );
     440             : 
     441             :                     // Commit changes.
     442          34 :                     xBatch->commitChanges();
     443          34 :                     return true;
     444           0 :                 }
     445           0 :             }
     446           0 :         }
     447             :     }
     448           0 :     catch ( lang::IllegalArgumentException const & )
     449             :     {
     450             :         // replaceByName, insertByName
     451             : 
     452             :         OSL_FAIL(
     453             :             "HierarchyEntry::setData - caught IllegalArgumentException!" );
     454             :     }
     455           0 :     catch ( uno::RuntimeException const & )
     456             :     {
     457           0 :         throw;
     458             :     }
     459           0 :     catch ( container::NoSuchElementException const & )
     460             :     {
     461             :         // replaceByName, getByName
     462             : 
     463             :         OSL_FAIL(
     464             :             "HierarchyEntry::setData - caught NoSuchElementException!" );
     465             :     }
     466           0 :     catch ( container::ElementExistException const & )
     467             :     {
     468             :         // insertByName
     469             : 
     470             :         OSL_FAIL(
     471             :             "HierarchyEntry::setData - caught ElementExistException!" );
     472             :     }
     473           0 :     catch ( lang::WrappedTargetException const & )
     474             :     {
     475             :         // replaceByName, insertByName, getByName, commitChanges
     476             : 
     477             :         OSL_FAIL(
     478             :             "HierarchyEntry::setData - caught WrappedTargetException!" );
     479             :     }
     480           0 :     catch ( uno::Exception const & )
     481             :     {
     482             :         // createInstance, createInstanceWithArguments
     483             : 
     484             :         OSL_FAIL(
     485             :             "HierarchyEntry::setData - caught Exception!" );
     486             :     }
     487             : 
     488           0 :     return false;
     489             : }
     490             : 
     491             : 
     492           0 : bool HierarchyEntry::move(
     493             :     const OUString& rNewURL, const HierarchyEntryData& rData )
     494             : {
     495           0 :     osl::Guard< osl::Mutex > aGuard( m_aMutex );
     496             : 
     497           0 :     OUString aNewPath = createPathFromHierarchyURL( rNewURL );
     498             : 
     499           0 :     if ( aNewPath == m_aPath )
     500           0 :         return true;
     501             : 
     502           0 :     bool bOldRoot = true;
     503           0 :     uno::Reference< util::XChangesBatch > xOldParentBatch;
     504             : 
     505           0 :     OUString aNewKey;
     506           0 :     sal_Int32 nURLPos = rNewURL.lastIndexOf( '/' );
     507           0 :     if ( nURLPos > HIERARCHY_URL_SCHEME_LENGTH )
     508           0 :         aNewKey = rNewURL.copy( nURLPos + 1 );
     509             :     else
     510             :     {
     511             :         OSL_FAIL( "HierarchyEntry::move - Invalid URL!" );
     512           0 :         return false;
     513             :     }
     514             : 
     515           0 :     bool bNewRoot = true;
     516           0 :     uno::Reference< util::XChangesBatch > xNewParentBatch;
     517             : 
     518           0 :     bool bDifferentParents = true;
     519             : 
     520             :     try
     521             :     {
     522           0 :         if ( !m_xConfigProvider.is() )
     523           0 :             m_xConfigProvider = uno::Reference< lang::XMultiServiceFactory >(
     524           0 :                 m_xContext->getServiceManager()->createInstanceWithContext(m_aServiceSpecifier, m_xContext),
     525           0 :                 uno::UNO_QUERY );
     526             : 
     527           0 :         if ( !m_xConfigProvider.is() )
     528           0 :             return false;
     529             : 
     530           0 :         OUString aOldParentPath;
     531           0 :         sal_Int32 nPos = m_aPath.lastIndexOf( '/' );
     532           0 :         if ( nPos != -1 )
     533             :         {
     534             :             // Skip "/Children" segment of the path, too.
     535           0 :             nPos = m_aPath.lastIndexOf( '/', nPos - 1 );
     536             : 
     537             :             OSL_ENSURE( nPos != -1, "HierarchyEntry::move - Wrong path!" );
     538             : 
     539           0 :             aOldParentPath += m_aPath.copy( 0, nPos );
     540           0 :             bOldRoot = false;
     541             :         }
     542             : 
     543           0 :         OUString aNewParentPath;
     544           0 :         nPos = aNewPath.lastIndexOf( '/' );
     545           0 :         if ( nPos != -1 )
     546             :         {
     547             :             // Skip "/Children" segment of the path, too.
     548           0 :             nPos = aNewPath.lastIndexOf( '/', nPos - 1 );
     549             : 
     550             :             OSL_ENSURE( nPos != -1, "HierarchyEntry::move - Wrong path!" );
     551             : 
     552           0 :             aNewParentPath += aNewPath.copy( 0, nPos );
     553           0 :             bNewRoot = false;
     554             :         }
     555             : 
     556           0 :         uno::Sequence< uno::Any > aArguments( 1 );
     557           0 :         beans::PropertyValue      aProperty;
     558             : 
     559           0 :         aProperty.Name  = OUString( CFGPROPERTY_NODEPATH  );
     560           0 :         aProperty.Value <<= aOldParentPath;
     561           0 :         aArguments[ 0 ] <<= aProperty;
     562             : 
     563           0 :         xOldParentBatch = uno::Reference< util::XChangesBatch >(
     564           0 :             m_xConfigProvider->createInstanceWithArguments(
     565             :                 OUString( READWRITE_SERVICE_NAME  ),
     566           0 :                 aArguments ),
     567           0 :             uno::UNO_QUERY );
     568             : 
     569             :         OSL_ENSURE( xOldParentBatch.is(), "HierarchyEntry::move - No batch!" );
     570             : 
     571           0 :         if ( !xOldParentBatch.is() )
     572           0 :             return false;
     573             : 
     574           0 :         if ( aOldParentPath == aNewParentPath )
     575             :         {
     576           0 :             bDifferentParents = false;
     577           0 :             xNewParentBatch = xOldParentBatch;
     578             :         }
     579             :         else
     580             :         {
     581           0 :             bDifferentParents = true;
     582             : 
     583           0 :             aProperty.Name    = OUString( CFGPROPERTY_NODEPATH  );
     584           0 :             aProperty.Value <<= aNewParentPath;
     585           0 :             aArguments[ 0 ] <<= aProperty;
     586             : 
     587           0 :             xNewParentBatch = uno::Reference< util::XChangesBatch >(
     588           0 :                 m_xConfigProvider->createInstanceWithArguments(
     589             :                     OUString( READWRITE_SERVICE_NAME  ),
     590           0 :                     aArguments ),
     591           0 :                 uno::UNO_QUERY );
     592             : 
     593             :             OSL_ENSURE(
     594             :                 xNewParentBatch.is(), "HierarchyEntry::move - No batch!" );
     595             : 
     596           0 :             if ( !xNewParentBatch.is() )
     597           0 :                 return false;
     598           0 :         }
     599             :     }
     600           0 :     catch ( uno::RuntimeException const & )
     601             :     {
     602           0 :         throw;
     603             :     }
     604           0 :     catch ( uno::Exception const & )
     605             :     {
     606             :         // createInstance, createInstanceWithArguments
     607             : 
     608             :         OSL_FAIL( "HierarchyEntry::move - caught Exception!" );
     609           0 :         return false;
     610             :     }
     611             : 
     612             : 
     613             :     // (1) Get entry...
     614             : 
     615             : 
     616           0 :     uno::Any aEntry;
     617           0 :     uno::Reference< container::XNameAccess >    xOldParentNameAccess;
     618           0 :     uno::Reference< container::XNameContainer > xOldNameContainer;
     619             : 
     620             :     try
     621             :     {
     622             :         xOldParentNameAccess
     623           0 :             = uno::Reference< container::XNameAccess >(
     624           0 :                 xOldParentBatch, uno::UNO_QUERY );
     625             : 
     626             :         OSL_ENSURE( xOldParentNameAccess.is(),
     627             :                     "HierarchyEntry::move - No name access!" );
     628             : 
     629           0 :         if ( !xOldParentNameAccess.is() )
     630           0 :             return false;
     631             : 
     632           0 :         if ( bOldRoot )
     633             :         {
     634           0 :             xOldNameContainer = uno::Reference< container::XNameContainer >(
     635           0 :                                         xOldParentNameAccess, uno::UNO_QUERY );
     636             :         }
     637             :         else
     638             :         {
     639           0 :             xOldParentNameAccess->getByName(
     640           0 :                  OUString("Children") )
     641           0 :                     >>= xOldNameContainer;
     642             :         }
     643             : 
     644           0 :         aEntry = xOldNameContainer->getByName( m_aName );
     645             :     }
     646           0 :     catch ( container::NoSuchElementException const & )
     647             :     {
     648             :         // getByName
     649             : 
     650             :         OSL_FAIL( "HierarchyEntry::move - caught NoSuchElementException!" );
     651           0 :         return false;
     652             :     }
     653           0 :     catch ( lang::WrappedTargetException const & )
     654             :     {
     655             :         // getByName
     656             : 
     657             :         OSL_FAIL( "HierarchyEntry::move - caught WrappedTargetException!" );
     658           0 :         return false;
     659             :     }
     660             : 
     661             : 
     662             :     // (2) Remove entry... Note: Insert BEFORE remove does not work!
     663             : 
     664             : 
     665             :     try
     666             :     {
     667           0 :         xOldNameContainer->removeByName( m_aName );
     668           0 :         xOldParentBatch->commitChanges();
     669             :     }
     670           0 :     catch ( container::NoSuchElementException const & )
     671             :     {
     672             :         // getByName, removeByName
     673             : 
     674             :         OSL_FAIL( "HierarchyEntry::move - caught NoSuchElementException!" );
     675           0 :         return false;
     676             :     }
     677             : 
     678             : 
     679             :     // (3) Insert entry at new parent...
     680             : 
     681             : 
     682             :     try
     683             :     {
     684           0 :         uno::Reference< container::XNameReplace > xNewNameReplace;
     685           0 :         aEntry >>= xNewNameReplace;
     686             : 
     687             :         OSL_ENSURE( xNewNameReplace.is(),
     688             :                     "HierarchyEntry::move - No name replace!" );
     689             : 
     690           0 :         if ( !xNewNameReplace.is() )
     691           0 :             return false;
     692             : 
     693           0 :         uno::Reference< container::XNameAccess > xNewParentNameAccess;
     694           0 :         if ( bDifferentParents )
     695             :             xNewParentNameAccess
     696           0 :                 = uno::Reference< container::XNameAccess >(
     697           0 :                     xNewParentBatch, uno::UNO_QUERY );
     698             :         else
     699           0 :             xNewParentNameAccess = xOldParentNameAccess;
     700             : 
     701             :         OSL_ENSURE( xNewParentNameAccess.is(),
     702             :                     "HierarchyEntry::move - No name access!" );
     703             : 
     704           0 :         if ( !xNewParentNameAccess.is() )
     705           0 :             return false;
     706             : 
     707           0 :         uno::Reference< container::XNameContainer > xNewNameContainer;
     708           0 :         if ( bDifferentParents )
     709             :         {
     710           0 :             if ( bNewRoot )
     711             :             {
     712             :                 xNewNameContainer
     713           0 :                     = uno::Reference< container::XNameContainer >(
     714           0 :                         xNewParentNameAccess, uno::UNO_QUERY );
     715             :             }
     716             :             else
     717             :             {
     718           0 :                 xNewParentNameAccess->getByName(
     719           0 :                      OUString("Children") )
     720           0 :                         >>= xNewNameContainer;
     721             :             }
     722             :         }
     723             :         else
     724           0 :             xNewNameContainer = xOldNameContainer;
     725             : 
     726           0 :         if ( !xNewNameContainer.is() )
     727           0 :             return false;
     728             : 
     729           0 :         xNewNameReplace->replaceByName(
     730             :             OUString("Title"),
     731           0 :             uno::makeAny( rData.getTitle() ) );
     732             : 
     733             :         // TargetURL property may contain a reference to the Office
     734             :         // installation directory. To ensure a reloctable office
     735             :         // installation, the path to the office installtion
     736             :         // directory must never be stored directly. Use a placeholder
     737             :         // instead.
     738           0 :         OUString aValue( rData.getTargetURL() );
     739           0 :         if ( m_xOfficeInstDirs.is() &&  !aValue.isEmpty() )
     740           0 :             aValue = m_xOfficeInstDirs->makeRelocatableURL( aValue );
     741           0 :         xNewNameReplace->replaceByName(
     742             :             OUString("TargetURL"),
     743           0 :             uno::makeAny( aValue ) );
     744           0 :         sal_Int32 nType = rData.getType() == HierarchyEntryData::LINK ? 0 : 1;
     745           0 :         xNewNameReplace->replaceByName(
     746             :             OUString("Type"),
     747           0 :             uno::makeAny( nType ) );
     748             : 
     749           0 :         xNewNameContainer->insertByName( aNewKey, aEntry );
     750           0 :         xNewParentBatch->commitChanges();
     751             :     }
     752           0 :     catch ( container::NoSuchElementException const & )
     753             :     {
     754             :         // replaceByName, insertByName, getByName
     755             : 
     756             :         OSL_FAIL( "HierarchyEntry::move - caught NoSuchElementException!" );
     757           0 :         return false;
     758             :     }
     759           0 :     catch ( lang::IllegalArgumentException const & )
     760             :     {
     761             :         // replaceByName, insertByName
     762             : 
     763             :         OSL_FAIL(
     764             :             "HierarchyEntry::move - caught IllegalArgumentException!" );
     765           0 :         return false;
     766             :     }
     767           0 :     catch ( container::ElementExistException const & )
     768             :     {
     769             :         // insertByName
     770             : 
     771             :         OSL_FAIL( "HierarchyEntry::move - caught ElementExistException!" );
     772           0 :         return false;
     773             :     }
     774           0 :     catch ( lang::WrappedTargetException const & )
     775             :     {
     776             :         // replaceByName, insertByName, getByName
     777             : 
     778             :         OSL_FAIL( "HierarchyEntry::move - caught WrappedTargetException!" );
     779           0 :         return false;
     780             :     }
     781             : 
     782           0 :     return true;
     783             : }
     784             : 
     785             : 
     786           0 : bool HierarchyEntry::remove()
     787             : {
     788             :     try
     789             :     {
     790           0 :         osl::Guard< osl::Mutex > aGuard( m_aMutex );
     791             : 
     792           0 :         if ( !m_xConfigProvider.is() )
     793           0 :             m_xConfigProvider = uno::Reference< lang::XMultiServiceFactory >(
     794           0 :                 m_xContext->getServiceManager()->createInstanceWithContext(m_aServiceSpecifier, m_xContext),
     795           0 :                 uno::UNO_QUERY );
     796             : 
     797           0 :         if ( m_xConfigProvider.is() )
     798             :         {
     799             :             // Create parent's key. It must exist!
     800             : 
     801           0 :             OUString aParentPath;
     802           0 :             bool bRoot = true;
     803             : 
     804           0 :             sal_Int32 nPos = m_aPath.lastIndexOf( '/' );
     805           0 :             if ( nPos != -1 )
     806             :             {
     807             :                 // Skip "/Children" segment of the path, too.
     808           0 :                 nPos = m_aPath.lastIndexOf( '/', nPos - 1 );
     809             : 
     810             :                 OSL_ENSURE( nPos != -1,
     811             :                             "HierarchyEntry::remove - Wrong path!" );
     812             : 
     813           0 :                 aParentPath += m_aPath.copy( 0, nPos );
     814           0 :                 bRoot = false;
     815             :             }
     816             : 
     817           0 :             uno::Sequence< uno::Any > aArguments( 1 );
     818           0 :             beans::PropertyValue      aProperty;
     819             : 
     820           0 :             aProperty.Name    = OUString( CFGPROPERTY_NODEPATH  );
     821           0 :             aProperty.Value <<= aParentPath;
     822           0 :             aArguments[ 0 ] <<= aProperty;
     823             : 
     824             :             uno::Reference< util::XChangesBatch > xBatch(
     825           0 :                 m_xConfigProvider->createInstanceWithArguments(
     826             :                     OUString( READWRITE_SERVICE_NAME  ),
     827           0 :                     aArguments ),
     828           0 :                 uno::UNO_QUERY );
     829             : 
     830             :             OSL_ENSURE( xBatch.is(),
     831             :                         "HierarchyEntry::remove - No batch!" );
     832             : 
     833             :             uno::Reference< container::XNameAccess > xParentNameAccess(
     834           0 :                 xBatch, uno::UNO_QUERY );
     835             : 
     836             :             OSL_ENSURE( xParentNameAccess.is(),
     837             :                         "HierarchyEntry::remove - No name access!" );
     838             : 
     839           0 :             if ( xBatch.is() && xParentNameAccess.is() )
     840             :             {
     841           0 :                 uno::Reference< container::XNameContainer > xContainer;
     842             : 
     843           0 :                 if ( bRoot )
     844             :                 {
     845             :                     // Special handling for children of root,
     846             :                     // which is not an entry. It's only a set
     847             :                     // of entries.
     848           0 :                     xContainer = uno::Reference< container::XNameContainer >(
     849           0 :                         xParentNameAccess, uno::UNO_QUERY );
     850             :                 }
     851             :                 else
     852             :                 {
     853             :                     // Append new entry to parents child list,
     854             :                     // which is a set of entries.
     855           0 :                      xParentNameAccess->getByName(
     856           0 :                         OUString("Children") )
     857           0 :                             >>= xContainer;
     858             :                 }
     859             : 
     860             :                 OSL_ENSURE( xContainer.is(),
     861             :                             "HierarchyEntry::remove - No container!" );
     862             : 
     863           0 :                 if ( xContainer.is() )
     864             :                 {
     865           0 :                     xContainer->removeByName( m_aName );
     866           0 :                     xBatch->commitChanges();
     867           0 :                     return true;
     868           0 :                 }
     869           0 :             }
     870           0 :         }
     871             :     }
     872           0 :     catch ( uno::RuntimeException const & )
     873             :     {
     874           0 :         throw;
     875             :     }
     876           0 :     catch ( container::NoSuchElementException const & )
     877             :     {
     878             :         // getByName, removeByName
     879             : 
     880             :         OSL_FAIL(
     881             :             "HierarchyEntry::remove - caught NoSuchElementException!" );
     882             :     }
     883           0 :     catch ( lang::WrappedTargetException const & )
     884             :     {
     885             :         // getByName, commitChanges
     886             : 
     887             :         OSL_FAIL(
     888             :             "HierarchyEntry::remove - caught WrappedTargetException!" );
     889             :     }
     890           0 :     catch ( uno::Exception const & )
     891             :     {
     892             :         // createInstance, createInstanceWithArguments
     893             : 
     894             :         OSL_FAIL( "HierarchyEntry::remove - caught Exception!" );
     895             :     }
     896             : 
     897           0 :     return false;
     898             : }
     899             : 
     900             : 
     901           8 : bool HierarchyEntry::first( iterator& it )
     902             : {
     903           8 :     osl::Guard< osl::Mutex > aGuard( m_aMutex );
     904             : 
     905           8 :     if ( it.m_pImpl->pos == -1 )
     906             :     {
     907             :         // Init...
     908             : 
     909             :         try
     910             :         {
     911             :             uno::Reference< container::XHierarchicalNameAccess >
     912           8 :                 xRootHierNameAccess = getRootReadAccess();
     913             : 
     914           8 :             if ( xRootHierNameAccess.is() )
     915             :             {
     916           8 :                 uno::Reference< container::XNameAccess > xNameAccess;
     917             : 
     918           8 :                 if ( !m_aPath.isEmpty() )
     919             :                 {
     920           8 :                     OUString aPath = m_aPath;
     921           8 :                     aPath += "/Children";
     922             : 
     923           8 :                     xRootHierNameAccess->getByHierarchicalName( aPath )
     924           8 :                         >>= xNameAccess;
     925             :                 }
     926             :                 else
     927             :                     xNameAccess
     928           0 :                         = uno::Reference< container::XNameAccess >(
     929           0 :                                 xRootHierNameAccess, uno::UNO_QUERY );
     930             : 
     931             :                 OSL_ENSURE( xNameAccess.is(),
     932             :                             "HierarchyEntry::first - No name access!" );
     933             : 
     934           8 :                 if ( xNameAccess.is() )
     935           8 :                     it.m_pImpl->names = xNameAccess->getElementNames();
     936             : 
     937             :                 uno::Reference< container::XHierarchicalNameAccess >
     938          16 :                     xHierNameAccess( xNameAccess, uno::UNO_QUERY );
     939             : 
     940             :                 OSL_ENSURE( xHierNameAccess.is(),
     941             :                             "HierarchyEntry::first - No hier. name access!" );
     942             : 
     943           8 :                 it.m_pImpl->dir = xHierNameAccess;
     944             : 
     945          16 :                 it.m_pImpl->officeDirs = m_xOfficeInstDirs;
     946           8 :             }
     947             :         }
     948           0 :         catch ( uno::RuntimeException const & )
     949             :         {
     950           0 :             throw;
     951             :         }
     952           0 :         catch ( container::NoSuchElementException const& )
     953             :         {
     954             :             // getByHierarchicalName
     955             : 
     956             :             OSL_FAIL(
     957             :                 "HierarchyEntry::first - caught NoSuchElementException!" );
     958             :         }
     959           0 :         catch ( uno::Exception const & )
     960             :         {
     961             :             OSL_FAIL( "HierarchyEntry::first - caught Exception!" );
     962             :         }
     963             :     }
     964             : 
     965           8 :     if ( it.m_pImpl->names.getLength() == 0 )
     966           4 :         return false;
     967             : 
     968           4 :     it.m_pImpl->pos = 0;
     969           4 :     return true;
     970             : }
     971             : 
     972             : 
     973          32 : bool HierarchyEntry::next( iterator& it )
     974             : {
     975          32 :     osl::Guard< osl::Mutex > aGuard( m_aMutex );
     976             : 
     977          32 :     if ( it.m_pImpl->pos == -1 )
     978           8 :         return first( it );
     979             : 
     980          24 :     ++(it.m_pImpl->pos);
     981             : 
     982          24 :     return ( it.m_pImpl->pos < it.m_pImpl->names.getLength() );
     983             : }
     984             : 
     985             : 
     986         118 : OUString HierarchyEntry::createPathFromHierarchyURL(
     987             :     const HierarchyUri& rURI )
     988             : {
     989             :     // Transform path....
     990             :     // folder/subfolder/subsubfolder
     991             :     //      --> ['folder']/Children/['subfolder']/Children/['subsubfolder']
     992             : 
     993         118 :     const OUString aPath = rURI.getPath().copy( 1 ); // skip leading slash.
     994         118 :     sal_Int32 nLen = aPath.getLength();
     995             : 
     996         118 :     if ( nLen )
     997             :     {
     998         118 :         OUStringBuffer aNewPath;
     999         118 :         aNewPath.appendAscii( "['" );
    1000             : 
    1001         118 :         sal_Int32 nStart = 0;
    1002         118 :         sal_Int32 nEnd   = aPath.indexOf( '/' );
    1003             : 
    1004         408 :         do
    1005             :         {
    1006         408 :             if ( nEnd == -1 )
    1007         118 :                 nEnd = nLen;
    1008             : 
    1009         408 :             OUString aToken = aPath.copy( nStart, nEnd - nStart );
    1010         408 :             makeXMLName( aToken, aNewPath );
    1011             : 
    1012         408 :             if ( nEnd != nLen )
    1013             :             {
    1014         290 :                 aNewPath.appendAscii( "']/Children/['" );
    1015         290 :                 nStart = nEnd + 1;
    1016         290 :                 nEnd   = aPath.indexOf( '/', nStart );
    1017             :             }
    1018             :             else
    1019         118 :                 aNewPath.appendAscii( "']" );
    1020             :         }
    1021             :         while ( nEnd != nLen );
    1022             : 
    1023         118 :         return aNewPath.makeStringAndClear();
    1024             :     }
    1025             : 
    1026           0 :     return aPath;
    1027             : }
    1028             : 
    1029             : 
    1030             : uno::Reference< container::XHierarchicalNameAccess >
    1031          84 : HierarchyEntry::getRootReadAccess()
    1032             : {
    1033          84 :     if ( !m_xRootReadAccess.is() )
    1034             :     {
    1035           0 :         osl::Guard< osl::Mutex > aGuard( m_aMutex );
    1036           0 :         if ( !m_xRootReadAccess.is() )
    1037             :         {
    1038           0 :             if ( m_bTriedToGetRootReadAccess ) // #82494#
    1039             :             {
    1040             :                 OSL_FAIL( "HierarchyEntry::getRootReadAccess - "
    1041             :                             "Unable to read any config data! -> #82494#" );
    1042           0 :                 return uno::Reference< container::XHierarchicalNameAccess >();
    1043             :             }
    1044             : 
    1045             :             try
    1046             :             {
    1047           0 :                 if ( !m_xConfigProvider.is() )
    1048             :                     m_xConfigProvider
    1049           0 :                         = uno::Reference< lang::XMultiServiceFactory >(
    1050           0 :                             m_xContext->getServiceManager()->createInstanceWithContext(m_aServiceSpecifier, m_xContext),
    1051           0 :                             uno::UNO_QUERY );
    1052             : 
    1053           0 :                 if ( m_xConfigProvider.is() )
    1054             :                 {
    1055             :                     // Create Root object.
    1056             : 
    1057           0 :                     uno::Sequence< uno::Any > aArguments( 1 );
    1058           0 :                     beans::PropertyValue      aProperty;
    1059           0 :                     aProperty.Name = OUString(
    1060           0 :                          CFGPROPERTY_NODEPATH  );
    1061           0 :                     aProperty.Value <<= OUString(); // root path
    1062           0 :                     aArguments[ 0 ] <<= aProperty;
    1063             : 
    1064           0 :                     m_bTriedToGetRootReadAccess = true;
    1065             : 
    1066             :                     m_xRootReadAccess
    1067           0 :                         = uno::Reference< container::XHierarchicalNameAccess >(
    1068           0 :                             m_xConfigProvider->createInstanceWithArguments(
    1069             :                                 OUString( READ_SERVICE_NAME  ),
    1070           0 :                                 aArguments ),
    1071           0 :                             uno::UNO_QUERY );
    1072             :                 }
    1073             :             }
    1074           0 :             catch ( uno::RuntimeException const & )
    1075             :             {
    1076           0 :                 throw;
    1077             :             }
    1078           0 :             catch ( uno::Exception const & )
    1079             :             {
    1080             :                 // createInstance, createInstanceWithArguments
    1081             : 
    1082             :                 OSL_FAIL( "HierarchyEntry::getRootReadAccess - "
    1083             :                             "caught Exception!" );
    1084             :             }
    1085           0 :         }
    1086             :     }
    1087          84 :     return m_xRootReadAccess;
    1088             : }
    1089             : 
    1090             : 
    1091             : 
    1092             : 
    1093             : // HierarchyEntry::iterator Implementation.
    1094             : 
    1095             : 
    1096             : 
    1097             : 
    1098           8 : HierarchyEntry::iterator::iterator()
    1099             : {
    1100           8 :     m_pImpl = new iterator_Impl;
    1101           8 : }
    1102             : 
    1103             : 
    1104           8 : HierarchyEntry::iterator::~iterator()
    1105             : {
    1106           8 :     delete m_pImpl;
    1107           8 : }
    1108             : 
    1109             : 
    1110          24 : const HierarchyEntryData& HierarchyEntry::iterator::operator*() const
    1111             : {
    1112          48 :     if ( ( m_pImpl->pos != -1 )
    1113          24 :          && ( m_pImpl->dir.is() )
    1114          48 :          && ( m_pImpl->pos < m_pImpl->names.getLength() ) )
    1115             :     {
    1116             :         try
    1117             :         {
    1118          24 :             OUStringBuffer aKey;
    1119          24 :             aKey.appendAscii( "['" );
    1120          24 :             makeXMLName( m_pImpl->names.getConstArray()[ m_pImpl->pos ], aKey );
    1121          24 :             aKey.appendAscii( "']" );
    1122             : 
    1123          48 :             OUString aTitle     = aKey.makeStringAndClear();
    1124          48 :             OUString aTargetURL = aTitle;
    1125          48 :             OUString aType      = aTitle;
    1126             : 
    1127          24 :             aTitle     += "/Title";
    1128          24 :             aTargetURL += "/TargetURL";
    1129          24 :             aType      += "/Type";
    1130             : 
    1131          48 :             OUString aValue;
    1132          24 :             m_pImpl->dir->getByHierarchicalName( aTitle ) >>= aValue;
    1133          24 :             m_pImpl->entry.setTitle( aValue );
    1134             : 
    1135          24 :             m_pImpl->dir->getByHierarchicalName( aTargetURL ) >>= aValue;
    1136             : 
    1137             :             // TargetURL property may contain a reference to the Office
    1138             :             // installation directory. To ensure a reloctable office
    1139             :             // installation, the path to the office installtion directory must
    1140             :             // never be stored directly. A placeholder is used instead. Replace
    1141             :             // it by actual installation directory.
    1142          24 :             if ( m_pImpl->officeDirs.is() && !aValue.isEmpty() )
    1143          20 :                 aValue = m_pImpl->officeDirs->makeAbsoluteURL( aValue );
    1144          24 :             m_pImpl->entry.setTargetURL( aValue );
    1145             : 
    1146          24 :             if ( m_pImpl->dir->hasByHierarchicalName( aType ) )
    1147             :             {
    1148             :                 // Might not be present since it was introduced long
    1149             :                 // after Title and TargetURL (#82433#)... So not getting
    1150             :                 // it is not an error.
    1151             : 
    1152             :                 // Get Type value.
    1153          24 :                 sal_Int32 nType = 0;
    1154          24 :                 if ( m_pImpl->dir->getByHierarchicalName( aType ) >>= nType )
    1155             :                 {
    1156          24 :                     if ( nType == 0 )
    1157             :                     {
    1158          20 :                         m_pImpl->entry.setType( HierarchyEntryData::LINK );
    1159             :                     }
    1160           4 :                     else if ( nType == 1 )
    1161             :                     {
    1162           4 :                         m_pImpl->entry.setType( HierarchyEntryData::FOLDER );
    1163             :                     }
    1164             :                     else
    1165             :                     {
    1166             :                         OSL_FAIL( "HierarchyEntry::getData - "
    1167             :                                     "Unknown Type value!" );
    1168             :                     }
    1169             :                 }
    1170             :             }
    1171             : 
    1172             :             m_pImpl->entry.setName(
    1173          48 :                 m_pImpl->names.getConstArray()[ m_pImpl->pos ] );
    1174             :         }
    1175           0 :         catch ( container::NoSuchElementException const & )
    1176             :         {
    1177           0 :             m_pImpl->entry = HierarchyEntryData();
    1178             :         }
    1179             :     }
    1180             : 
    1181          24 :     return m_pImpl->entry;
    1182             : }
    1183             : 
    1184             : } // namespace hierarchy_ucp
    1185             : 
    1186             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10