ucbhelper/source/provider/providerhelper.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <sal/config.h>
  21
  22 #include <com/sun/star/beans/IllegalTypeException.hpp>
  23 #include <com/sun/star/beans/PropertyExistException.hpp>
  24 #include <com/sun/star/beans/XPropertyAccess.hpp>
  25 #include <com/sun/star/container/XNameAccess.hpp>
  26 #include <com/sun/star/container/XNamed.hpp>
  27 #include <com/sun/star/ucb/Store.hpp>
  28 #include <com/sun/star/ucb/XPropertySetRegistry.hpp>
  29 #include <com/sun/star/ucb/XPropertySetRegistryFactory.hpp>
  30 #include <cppuhelper/supportsservice.hxx>
  31 #include <cppuhelper/queryinterface.hxx>
  32 #include <ucbhelper/contenthelper.hxx>
  33 #include <ucbhelper/contentidentifier.hxx>
  34 #include <ucbhelper/providerhelper.hxx>
  35 #include <ucbhelper/macros.hxx>
  36
  37 #include <osl/diagnose.h>
  38 #include <osl/mutex.hxx>
  39 #include <cppuhelper/weakref.hxx>
  40
  41 #include <unordered_map>
  42
  43 using namespace com::sun::star;
  44
  45 namespace ucbhelper_impl
  46 {
  47
  48 typedef std::unordered_map
  49 <
  50     OUString,
  51     uno::WeakReference< ucb::XContent >
  52 >
  53 Contents;
  54
  55 struct ContentProviderImplHelper_Impl
  56 {
  57     uno::Reference< css::ucb::XPropertySetRegistry >  m_xPropertySetRegistry;
  58     Contents                                          m_aContents;
  59 };
  60
  61 } // namespace ucbhelper_impl
  62
  63 namespace ucbhelper {
  64
  65 ContentProviderImplHelper::ContentProviderImplHelper(
  66     const uno::Reference< uno::XComponentContext >& rxContext )
  67 : m_pImpl( new ucbhelper_impl::ContentProviderImplHelper_Impl ),
  68   m_xContext( rxContext )
  69 {
  70 }
  71
  72 // virtual
  73 ContentProviderImplHelper::~ContentProviderImplHelper()
  74 {
  75 }
  76
  77 // XInterface
  78 void SAL_CALL ContentProviderImplHelper::acquire()
  79     throw()
  80 {
  81     OWeakObject::acquire();
  82 }
  83
  84 void SAL_CALL ContentProviderImplHelper::release()
  85     throw()
  86 {
  87     OWeakObject::release();
  88 }
  89
  90 css::uno::Any SAL_CALL ContentProviderImplHelper::queryInterface( const css::uno::Type & rType )
  91 {
  92     css::uno::Any aRet = cppu::queryInterface( rType,
  93                                                static_cast< lang::XTypeProvider* >(this),
  94                                                static_cast< lang::XServiceInfo* >(this),
  95                                                static_cast< css::ucb::XContentProvider* >(this)
  96                                                );
  97     return aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType );
  98 }
  99
 100 XTYPEPROVIDER_IMPL_3( ContentProviderImplHelper,
 101                          lang::XTypeProvider,
 102                          lang::XServiceInfo,
 103                          css::ucb::XContentProvider );
 104
 105 // virtual
 106 sal_Bool SAL_CALL ContentProviderImplHelper::supportsService(
 107                                             const OUString& ServiceName )
 108 {
 109     return cppu::supportsService(this, ServiceName);
 110 }
 111
 112 // virtual
 113 sal_Int32 SAL_CALL ContentProviderImplHelper::compareContentIds(
 114         const uno::Reference< css::ucb::XContentIdentifier >& Id1,
 115         const uno::Reference< css::ucb::XContentIdentifier >& Id2 )
 116 {
 117     // Simply do a string compare.
 118
 119     OUString aURL1( Id1->getContentIdentifier() );
 120     OUString aURL2( Id2->getContentIdentifier() );
 121
 122     return aURL1.compareTo( aURL2 );
 123 }
 124
 125 void ContentProviderImplHelper::cleanupRegisteredContents()
 126 {
 127     osl::MutexGuard aGuard( m_aMutex );
 128
 129     ucbhelper_impl::Contents::iterator it
 130         = m_pImpl->m_aContents.begin();
 131     while( it != m_pImpl->m_aContents.end() )
 132     {
 133         uno::Reference< ucb::XContent > xContent( (*it).second );
 134         if ( !xContent.is() )
 135         {
 136             ucbhelper_impl::Contents::iterator tmp = it;
 137             ++it;
 138             m_pImpl->m_aContents.erase( tmp );
 139         }
 140         else
 141         {
 142             ++it;
 143         }
 144     }
 145 }
 146
 147 void ContentProviderImplHelper::removeContent( ContentImplHelper* pContent )
 148 {
 149     osl::MutexGuard aGuard( m_aMutex );
 150
 151     cleanupRegisteredContents();
 152
 153     const OUString aURL(
 154         pContent->getIdentifier()->getContentIdentifier() );
 155
 156     ucbhelper_impl::Contents::iterator it = m_pImpl->m_aContents.find( aURL );
 157
 158     if ( it != m_pImpl->m_aContents.end() )
 159         m_pImpl->m_aContents.erase( it );
 160 }
 161
 162 rtl::Reference< ContentImplHelper >
 163 ContentProviderImplHelper::queryExistingContent(
 164     const uno::Reference< css::ucb::XContentIdentifier >& Identifier )
 165 {
 166     return queryExistingContent( Identifier->getContentIdentifier() );
 167 }
 168
 169 rtl::Reference< ContentImplHelper >
 170 ContentProviderImplHelper::queryExistingContent( const OUString& rURL )
 171 {
 172     osl::MutexGuard aGuard( m_aMutex );
 173
 174     cleanupRegisteredContents();
 175
 176     // Check, if a content with given id already exists...
 177
 178     ucbhelper_impl::Contents::const_iterator it
 179         = m_pImpl->m_aContents.find( rURL );
 180     if ( it != m_pImpl->m_aContents.end() )
 181     {
 182         uno::Reference< ucb::XContent > xContent( (*it).second );
 183         if ( xContent.is() )
 184         {
 185             return rtl::Reference< ContentImplHelper >(
 186                 static_cast< ContentImplHelper * >( xContent.get() ) );
 187         }
 188     }
 189     return rtl::Reference< ContentImplHelper >();
 190 }
 191
 192 void ContentProviderImplHelper::queryExistingContents(
 193         ContentRefList& rContents )
 194 {
 195     osl::MutexGuard aGuard( m_aMutex );
 196
 197     cleanupRegisteredContents();
 198
 199     for ( const auto& rContent : m_pImpl->m_aContents )
 200     {
 201         uno::Reference< ucb::XContent > xContent( rContent.second );
 202         if ( xContent.is() )
 203         {
 204             rContents.emplace_back(
 205                     static_cast< ContentImplHelper * >( xContent.get() ) );
 206         }
 207     }
 208 }
 209
 210 void ContentProviderImplHelper::registerNewContent(
 211     const uno::Reference< ucb::XContent > & xContent )
 212 {
 213     if ( xContent.is() )
 214     {
 215         osl::MutexGuard aGuard( m_aMutex );
 216
 217         cleanupRegisteredContents();
 218
 219         const OUString aURL(
 220             xContent->getIdentifier()->getContentIdentifier() );
 221         ucbhelper_impl::Contents::const_iterator it
 222             = m_pImpl->m_aContents.find( aURL );
 223         if ( it == m_pImpl->m_aContents.end() )
 224             m_pImpl->m_aContents[ aURL ] = xContent;
 225     }
 226 }
 227
 228 uno::Reference< css::ucb::XPropertySetRegistry >
 229 ContentProviderImplHelper::getAdditionalPropertySetRegistry()
 230 {
 231     // Get propertyset registry.
 232
 233     osl::MutexGuard aGuard( m_aMutex );
 234
 235     if ( !m_pImpl->m_xPropertySetRegistry.is() )
 236     {
 237         uno::Reference< css::ucb::XPropertySetRegistryFactory >
 238             xRegFac = css::ucb::Store::create( m_xContext );
 239
 240         // Open/create a registry.
 241         m_pImpl->m_xPropertySetRegistry
 242             = xRegFac->createPropertySetRegistry( OUString() );
 243
 244         OSL_ENSURE( m_pImpl->m_xPropertySetRegistry.is(),
 245                 "ContentProviderImplHelper::getAdditionalPropertySet - "
 246                 "Error opening registry!" );
 247     }
 248
 249     return m_pImpl->m_xPropertySetRegistry;
 250 }
 251
 252 uno::Reference< css::ucb::XPersistentPropertySet >
 253 ContentProviderImplHelper::getAdditionalPropertySet(
 254     const OUString& rKey, bool bCreate )
 255 {
 256     // Get propertyset registry.
 257     getAdditionalPropertySetRegistry();
 258
 259     if ( m_pImpl->m_xPropertySetRegistry.is() )
 260     {
 261         // Open/create persistent property set.
 262         return m_pImpl->m_xPropertySetRegistry->openPropertySet(
 263                 rKey, bCreate );
 264     }
 265
 266     return uno::Reference< css::ucb::XPersistentPropertySet >();
 267 }
 268
 269 bool ContentProviderImplHelper::renameAdditionalPropertySet(
 270     const OUString& rOldKey,
 271     const OUString& rNewKey,
 272     bool bRecursive )
 273 {
 274     if ( rOldKey == rNewKey )
 275         return true;
 276
 277     osl::MutexGuard aGuard( m_aMutex );
 278
 279     if ( bRecursive )
 280     {
 281         // Get propertyset registry.
 282         getAdditionalPropertySetRegistry();
 283
 284         if ( m_pImpl->m_xPropertySetRegistry.is() )
 285         {
 286             uno::Reference< container::XNameAccess > xNameAccess(
 287                 m_pImpl->m_xPropertySetRegistry, uno::UNO_QUERY );
 288             if ( xNameAccess.is() )
 289             {
 290                 uno::Sequence< OUString > aKeys
 291                     = xNameAccess->getElementNames();
 292                 sal_Int32 nCount = aKeys.getLength();
 293                 if ( nCount > 0 )
 294                 {
 295                     OUString aOldKeyWithSlash = rOldKey;
 296                     OUString aOldKeyWithoutSlash;
 297                     if ( !aOldKeyWithSlash.endsWith("/") )
 298                     {
 299                         aOldKeyWithSlash += "/";
 300                         aOldKeyWithoutSlash = rOldKey;
 301                     }
 302                     else if ( !rOldKey.isEmpty() )
 303                         aOldKeyWithoutSlash
 304                             = rOldKey.copy( 0, rOldKey.getLength() - 1 );
 305
 306                     const OUString* pKeys = aKeys.getConstArray();
 307                     for ( sal_Int32 n = 0; n < nCount; ++n )
 308                     {
 309                         const OUString& rKey = pKeys[ n ];
 310                         if ( rKey.startsWith( aOldKeyWithSlash )
 311                              || rKey == aOldKeyWithoutSlash )
 312                         {
 313                             OUString aNewKey
 314                                 = rKey.replaceAt(
 315                                     0, rOldKey.getLength(), rNewKey );
 316                             if ( !renameAdditionalPropertySet(
 317                                     rKey, aNewKey, false ) )
 318                                 return false;
 319                         }
 320                     }
 321                 }
 322             }
 323             else
 324                 return false;
 325         }
 326         else
 327             return false;
 328     }
 329     else
 330     {
 331         // Get old property set, if exists.
 332         uno::Reference< css::ucb::XPersistentPropertySet > xOldSet
 333             = getAdditionalPropertySet( rOldKey, false );
 334         if ( xOldSet.is() )
 335         {
 336             // Rename property set.
 337             uno::Reference< container::XNamed > xNamed(
 338                 xOldSet, uno::UNO_QUERY );
 339             if ( xNamed.is() )
 340             {
 341                 // ??? throws no exceptions and has no return value ???
 342                 xNamed->setName( rNewKey );
 343             }
 344             else
 345                 return false;
 346         }
 347     }
 348     return true;
 349 }
 350
 351 bool ContentProviderImplHelper::copyAdditionalPropertySet(
 352     const OUString& rSourceKey,
 353     const OUString& rTargetKey,
 354     bool bRecursive )
 355 {
 356     if ( rSourceKey == rTargetKey )
 357         return true;
 358
 359     osl::MutexGuard aGuard( m_aMutex );
 360
 361     if ( bRecursive )
 362     {
 363         // Get propertyset registry.
 364         getAdditionalPropertySetRegistry();
 365
 366         if ( m_pImpl->m_xPropertySetRegistry.is() )
 367         {
 368             uno::Reference< container::XNameAccess > xNameAccess(
 369                 m_pImpl->m_xPropertySetRegistry, uno::UNO_QUERY );
 370             if ( xNameAccess.is() )
 371             {
 372                 uno::Sequence< OUString > aKeys
 373                     = xNameAccess->getElementNames();
 374                 sal_Int32 nCount = aKeys.getLength();
 375                 if ( nCount > 0 )
 376                 {
 377                     OUString aSrcKeyWithSlash = rSourceKey;
 378                     OUString aSrcKeyWithoutSlash;
 379                     if ( !aSrcKeyWithSlash.endsWith("/") )
 380                     {
 381                         aSrcKeyWithSlash += "/";
 382                         aSrcKeyWithoutSlash = rSourceKey;
 383                     }
 384                     else if ( !rSourceKey.isEmpty() )
 385                         aSrcKeyWithoutSlash = rSourceKey.copy(
 386                             0, rSourceKey.getLength() - 1 );
 387
 388                     const OUString* pKeys = aKeys.getConstArray();
 389                     for ( sal_Int32 n = 0; n < nCount; ++n )
 390                     {
 391                         const OUString& rKey = pKeys[ n ];
 392                         if ( rKey.startsWith(aSrcKeyWithSlash )
 393                              || rKey == aSrcKeyWithoutSlash )
 394                         {
 395                             OUString aNewKey
 396                                 = rKey.replaceAt(
 397                                     0, rSourceKey.getLength(), rTargetKey );
 398                             if ( !copyAdditionalPropertySet(
 399                                     rKey, aNewKey, false ) )
 400                                 return false;
 401                         }
 402                     }
 403                 }
 404             }
 405             else
 406                 return false;
 407         }
 408         else
 409             return false;
 410     }
 411     else
 412     {
 413         // Get old property set, if exists.
 414         uno::Reference< css::ucb::XPersistentPropertySet >
 415             xOldPropSet = getAdditionalPropertySet( rSourceKey, false );
 416         if ( !xOldPropSet.is() )
 417             return false;
 418
 419         uno::Reference< beans::XPropertySetInfo > xPropSetInfo
 420             = xOldPropSet->getPropertySetInfo();
 421         if ( !xPropSetInfo.is() )
 422             return false;
 423
 424         uno::Reference< beans::XPropertyAccess > xOldPropAccess(
 425             xOldPropSet, uno::UNO_QUERY );
 426         if ( !xOldPropAccess.is() )
 427             return false;
 428
 429         // Obtain all values from old set.
 430         uno::Sequence< beans::PropertyValue > aValues
 431             = xOldPropAccess->getPropertyValues();
 432         sal_Int32 nCount = aValues.getLength();
 433
 434         uno::Sequence< beans::Property > aProps
 435             = xPropSetInfo->getProperties();
 436
 437         if ( nCount )
 438         {
 439             // Fail, if property set with new key already exists.
 440             uno::Reference< css::ucb::XPersistentPropertySet >
 441                 xNewPropSet
 442                     = getAdditionalPropertySet( rTargetKey, false );
 443             if ( xNewPropSet.is() )
 444                 return false;
 445
 446             // Create new, empty set.
 447             xNewPropSet = getAdditionalPropertySet( rTargetKey, true );
 448             if ( !xNewPropSet.is() )
 449                 return false;
 450
 451             uno::Reference< beans::XPropertyContainer > xNewPropContainer(
 452                 xNewPropSet, uno::UNO_QUERY );
 453             if ( !xNewPropContainer.is() )
 454                 return false;
 455
 456             for ( sal_Int32 n = 0; n < nCount; ++n )
 457             {
 458                 const beans::PropertyValue& rValue = aValues[ n ];
 459
 460                 sal_Int16 nAttribs = 0;
 461                 for ( sal_Int32 m = 0; m < aProps.getLength(); ++m )
 462                 {
 463                     if ( aProps[ m ].Name == rValue.Name )
 464                     {
 465                         nAttribs = aProps[ m ].Attributes;
 466                         break;
 467                     }
 468                 }
 469
 470                 try
 471                 {
 472                     xNewPropContainer->addProperty(
 473                         rValue.Name, nAttribs, rValue.Value );
 474                 }
 475                 catch ( beans::PropertyExistException & )
 476                 {
 477                 }
 478                    catch ( beans::IllegalTypeException & )
 479                 {
 480                 }
 481                 catch ( lang::IllegalArgumentException & )
 482                 {
 483                 }
 484             }
 485         }
 486     }
 487     return true;
 488 }
 489
 490 bool ContentProviderImplHelper::removeAdditionalPropertySet(
 491     const OUString& rKey, bool bRecursive )
 492 {
 493     osl::MutexGuard aGuard( m_aMutex );
 494
 495     if ( bRecursive )
 496     {
 497         // Get propertyset registry.
 498         getAdditionalPropertySetRegistry();
 499
 500         if ( m_pImpl->m_xPropertySetRegistry.is() )
 501         {
 502             uno::Reference< container::XNameAccess > xNameAccess(
 503                 m_pImpl->m_xPropertySetRegistry, uno::UNO_QUERY );
 504             if ( xNameAccess.is() )
 505             {
 506                 uno::Sequence< OUString > aKeys
 507                     = xNameAccess->getElementNames();
 508                 sal_Int32 nCount = aKeys.getLength();
 509                 if ( nCount > 0 )
 510                 {
 511                     OUString aKeyWithSlash = rKey;
 512                     OUString aKeyWithoutSlash;
 513                     if ( !aKeyWithSlash.endsWith("/") )
 514                     {
 515                         aKeyWithSlash += "/";
 516                         aKeyWithoutSlash = rKey;
 517                     }
 518                     else if ( !rKey.isEmpty() )
 519                         aKeyWithoutSlash
 520                             = rKey.copy( 0, rKey.getLength() - 1 );
 521
 522                     const OUString* pKeys = aKeys.getConstArray();
 523                     for ( sal_Int32 n = 0; n < nCount; ++n )
 524                     {
 525                         const OUString& rCurrKey = pKeys[ n ];
 526                         if ( rCurrKey.startsWith(aKeyWithSlash )
 527                              || rCurrKey == aKeyWithoutSlash )
 528                         {
 529                             if ( !removeAdditionalPropertySet(
 530                                      rCurrKey, false ) )
 531                                 return false;
 532                         }
 533                     }
 534                 }
 535             }
 536             else
 537                 return false;
 538         }
 539         else
 540             return false;
 541     }
 542     else
 543     {
 544         // Get propertyset registry.
 545         getAdditionalPropertySetRegistry();
 546
 547         if ( m_pImpl->m_xPropertySetRegistry.is() )
 548             m_pImpl->m_xPropertySetRegistry->removePropertySet( rKey );
 549         else
 550             return false;
 551     }
 552     return true;
 553 }
 554
 555 } // namespace ucbhelper
 556
 557 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */