ucb/source/ucp/hierarchy/hierarchydata.cxx

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