framework/source/accelerators/storageholder.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 <accelerators/storageholder.hxx>
  21
  22 #include <threadhelp/readguard.hxx>
  23 #include <threadhelp/writeguard.hxx>
  24 #include <services.h>
  25
  26 #include <com/sun/star/container/NoSuchElementException.hpp>
  27
  28 #include <com/sun/star/container/XNameAccess.hpp>
  29
  30 #include <com/sun/star/beans/XPropertySet.hpp>
  31
  32 #include <com/sun/star/embed/ElementModes.hpp>
  33
  34 #include <com/sun/star/embed/XTransactedObject.hpp>
  35
  36 #include <com/sun/star/embed/XPackageStructureCreator.hpp>
  37
  38 #include <com/sun/star/lang/XSingleServiceFactory.hpp>
  39
  40 #include <com/sun/star/io/XSeekable.hpp>
  41
  42
  43 #define PATH_SEPARATOR_ASCII        "/"
  44 #define PATH_SEPARATOR_UNICODE      ((sal_Unicode)'/')
  45 #define PATH_SEPARATOR              OUString(PATH_SEPARATOR_ASCII)
  46
  47
  48 namespace framework
  49 {
  50
  51 //-----------------------------------------------
  52 StorageHolder::StorageHolder()
  53     : ThreadHelpBase(                                        )
  54 {
  55 }
  56
  57 //-----------------------------------------------
  58 StorageHolder::~StorageHolder()
  59 {
  60     // TODO implement me
  61     // dispose/clear etcpp.
  62 }
  63
  64 //-----------------------------------------------
  65 void StorageHolder::forgetCachedStorages()
  66 {
  67     // SAFE -> ----------------------------------
  68     WriteGuard aWriteLock(m_aLock);
  69
  70     TPath2StorageInfo::iterator pIt;
  71     for (  pIt  = m_lStorages.begin();
  72            pIt != m_lStorages.end()  ;
  73          ++pIt                       )
  74     {
  75         TStorageInfo& rInfo = pIt->second;
  76         // TODO think about listener !
  77         rInfo.Storage.clear();
  78     }
  79     m_lStorages.clear();
  80
  81     aWriteLock.unlock();
  82     // <- SAFE ----------------------------------
  83 }
  84
  85 //-----------------------------------------------
  86 void StorageHolder::setRootStorage(const css::uno::Reference< css::embed::XStorage >& xRoot)
  87 {
  88     // SAFE -> ----------------------------------
  89     WriteGuard aWriteLock(m_aLock);
  90     m_xRoot = xRoot;
  91     aWriteLock.unlock();
  92     // <- SAFE ----------------------------------
  93 }
  94
  95 //-----------------------------------------------
  96 css::uno::Reference< css::embed::XStorage > StorageHolder::getRootStorage() const
  97 {
  98     // SAFE -> ----------------------------------
  99     ReadGuard aReadLock(m_aLock);
 100     return m_xRoot;
 101     // <- SAFE ----------------------------------
 102 }
 103
 104 //-----------------------------------------------
 105 css::uno::Reference< css::embed::XStorage > StorageHolder::openPath(const OUString& sPath    ,
 106                                                                           sal_Int32        nOpenMode)
 107 {
 108     OUString sNormedPath = StorageHolder::impl_st_normPath(sPath);
 109     OUStringList    lFolders    = StorageHolder::impl_st_parsePath(sNormedPath);
 110
 111     // SAFE -> ----------------------------------
 112     ReadGuard aReadLock(m_aLock);
 113     css::uno::Reference< css::embed::XStorage > xParent = m_xRoot;
 114     aReadLock.unlock();
 115     // <- SAFE ----------------------------------
 116
 117     css::uno::Reference< css::embed::XStorage > xChild  ;
 118     OUString                             sRelPath;
 119     OUStringList::const_iterator                pIt     ;
 120
 121     for (  pIt  = lFolders.begin();
 122            pIt != lFolders.end()  ;
 123          ++pIt                    )
 124     {
 125         const OUString& sChild     = *pIt;
 126               OUString  sCheckPath (sRelPath);
 127                                sCheckPath += sChild;
 128                                sCheckPath += PATH_SEPARATOR;
 129
 130         // SAFE -> ------------------------------
 131         aReadLock.lock();
 132
 133         // If we found an already open storage ... we must increase
 134         // its use count. Otherwhise it will may be closed to early :-)
 135         TPath2StorageInfo::iterator pCheck = m_lStorages.find(sCheckPath);
 136         TStorageInfo*               pInfo  = 0;
 137         if (pCheck != m_lStorages.end())
 138         {
 139             pInfo = &(pCheck->second);
 140             ++(pInfo->UseCount);
 141             xChild = pInfo->Storage;
 142         }
 143         else
 144         {
 145             aReadLock.unlock();
 146             // <- SAFE ------------------------------
 147
 148             try
 149             {
 150                 xChild = StorageHolder::openSubStorageWithFallback(xParent, sChild, nOpenMode, sal_True); // TODO think about delegating fallback decision to our own calli!
 151             }
 152             catch(const css::uno::RuntimeException&)
 153                 { throw; }
 154             catch(const css::uno::Exception&)
 155                 {
 156                     /* TODO URGENT!
 157                         in case we found some "already existing storages" on the path before and increased its UseCount ...
 158                         and now we will get an exception on creating a new sub storage ...
 159                         we must decrease all UseCounts, which was touched before. Otherwise these storages cant be closed!
 160
 161                         Idea: Using of another structure member "PossibleUseCount" as vector of unique numbers.
 162                         Every thread use another unique number to identify all "owned candidates".
 163                         A flush method with the same unique number force increasing of the "UseCount" variable then
 164                         inside a synchronized block ...
 165                     */
 166                     throw;
 167                 }
 168
 169             // SAFE -> ------------------------------
 170             WriteGuard aWriteLock(m_aLock);
 171             pInfo = &(m_lStorages[sCheckPath]);
 172             pInfo->Storage  = xChild;
 173             pInfo->UseCount = 1;
 174             aWriteLock.unlock();
 175             // <- SAFE ------------------------------
 176         }
 177
 178         xParent   = xChild;
 179         sRelPath += sChild;
 180         sRelPath += PATH_SEPARATOR;
 181     }
 182
 183     // TODO think about return last storage as working storage ... but dont caching it inside this holder!
 184     // => otherwise the same storage is may be commit more then once.
 185
 186     return xChild;
 187 }
 188
 189 //-----------------------------------------------
 190 StorageHolder::TStorageList StorageHolder::getAllPathStorages(const OUString& sPath)
 191 {
 192     OUString sNormedPath = StorageHolder::impl_st_normPath(sPath);
 193     OUStringList    lFolders    = StorageHolder::impl_st_parsePath(sNormedPath);
 194
 195     StorageHolder::TStorageList  lStoragesOfPath;
 196     OUString              sRelPath       ;
 197     OUStringList::const_iterator pIt            ;
 198
 199     // SAFE -> ----------------------------------
 200     ReadGuard aReadLock(m_aLock);
 201
 202     for (  pIt  = lFolders.begin();
 203            pIt != lFolders.end()  ;
 204          ++pIt                    )
 205     {
 206         const OUString& sChild     = *pIt;
 207               OUString  sCheckPath (sRelPath);
 208                                sCheckPath += sChild;
 209                                sCheckPath += PATH_SEPARATOR;
 210
 211         TPath2StorageInfo::iterator pCheck = m_lStorages.find(sCheckPath);
 212         if (pCheck == m_lStorages.end())
 213         {
 214             // at least one path element was not found
 215             // Seems that this path isnt open ...
 216             lStoragesOfPath.clear();
 217             return lStoragesOfPath;
 218         }
 219
 220         TStorageInfo& rInfo = pCheck->second;
 221         lStoragesOfPath.push_back(rInfo.Storage);
 222
 223         sRelPath += sChild;
 224         sRelPath += PATH_SEPARATOR;
 225     }
 226
 227     aReadLock.unlock();
 228     // <- SAFE ----------------------------------
 229
 230     return lStoragesOfPath;
 231 }
 232
 233 //-----------------------------------------------
 234 void StorageHolder::commitPath(const OUString& sPath)
 235 {
 236     StorageHolder::TStorageList lStorages = getAllPathStorages(sPath);
 237
 238     css::uno::Reference< css::embed::XTransactedObject > xCommit;
 239     StorageHolder::TStorageList::reverse_iterator pIt;
 240     for (  pIt  = lStorages.rbegin(); // order of commit is important ... otherwise changes are not recognized!
 241            pIt != lStorages.rend()  ;
 242          ++pIt                      )
 243     {
 244         xCommit = css::uno::Reference< css::embed::XTransactedObject >(*pIt, css::uno::UNO_QUERY);
 245         if (!xCommit.is())
 246             continue;
 247         xCommit->commit();
 248     }
 249
 250     // SAFE -> ------------------------------
 251     ReadGuard aReadLock(m_aLock);
 252     xCommit = css::uno::Reference< css::embed::XTransactedObject >(m_xRoot, css::uno::UNO_QUERY);
 253     aReadLock.unlock();
 254     // <- SAFE ------------------------------
 255
 256     if (xCommit.is())
 257         xCommit->commit();
 258 }
 259
 260 //-----------------------------------------------
 261 void StorageHolder::closePath(const OUString& rPath)
 262 {
 263     OUString sNormedPath = StorageHolder::impl_st_normPath(rPath);
 264     OUStringList    lFolders    = StorageHolder::impl_st_parsePath(sNormedPath);
 265
 266     /* convert list of paths in the following way:
 267         [0] = "path_1" => "path_1
 268         [1] = "path_2" => "path_1/path_2"
 269         [2] = "path_3" => "path_1/path_2/path_3"
 270     */
 271     OUStringList::iterator pIt1       ;
 272     OUString        sParentPath;
 273     for (  pIt1  = lFolders.begin();
 274            pIt1 != lFolders.end()  ;
 275          ++pIt1                    )
 276     {
 277         OUString sCurrentRelPath  = sParentPath;
 278                         sCurrentRelPath += *pIt1;
 279                         sCurrentRelPath += PATH_SEPARATOR;
 280         *pIt1       = sCurrentRelPath;
 281         sParentPath = sCurrentRelPath;
 282     }
 283
 284     // SAFE -> ------------------------------
 285     ReadGuard aReadLock(m_aLock);
 286
 287     OUStringList::reverse_iterator pIt2;
 288     for (  pIt2  = lFolders.rbegin();
 289            pIt2 != lFolders.rend()  ;
 290          ++pIt2                     )
 291     {
 292         OUString             sPath = *pIt2;
 293         TPath2StorageInfo::iterator pPath = m_lStorages.find(sPath);
 294         if (pPath == m_lStorages.end())
 295             continue; // ???
 296
 297         TStorageInfo& rInfo = pPath->second;
 298         --rInfo.UseCount;
 299         if (rInfo.UseCount < 1)
 300         {
 301             rInfo.Storage.clear();
 302             m_lStorages.erase(pPath);
 303         }
 304     }
 305
 306     aReadLock.unlock();
 307     // <- SAFE ------------------------------
 308 }
 309
 310 //-----------------------------------------------
 311 void StorageHolder::notifyPath(const OUString& sPath)
 312 {
 313     OUString sNormedPath = StorageHolder::impl_st_normPath(sPath);
 314
 315     // SAFE -> ------------------------------
 316     ReadGuard aReadLock(m_aLock);
 317
 318     TPath2StorageInfo::iterator pIt1 = m_lStorages.find(sNormedPath);
 319     if (pIt1 == m_lStorages.end())
 320         return;
 321
 322     TStorageInfo& rInfo = pIt1->second;
 323     TStorageListenerList::iterator pIt2;
 324     for (  pIt2  = rInfo.Listener.begin();
 325            pIt2 != rInfo.Listener.end()  ;
 326          ++pIt2                          )
 327     {
 328         IStorageListener* pListener = *pIt2;
 329         if (pListener)
 330             pListener->changesOccurred(sNormedPath);
 331     }
 332
 333     aReadLock.unlock();
 334     // <- SAFE ------------------------------
 335 }
 336
 337 //-----------------------------------------------
 338 void StorageHolder::addStorageListener(      IStorageListener* pListener,
 339                                        const OUString&  sPath    )
 340 {
 341     OUString sNormedPath = StorageHolder::impl_st_normPath(sPath);
 342
 343     // SAFE -> ------------------------------
 344     ReadGuard aReadLock(m_aLock);
 345
 346     TPath2StorageInfo::iterator pIt1 = m_lStorages.find(sNormedPath);
 347     if (pIt1 == m_lStorages.end())
 348         return;
 349
 350     TStorageInfo& rInfo = pIt1->second;
 351     TStorageListenerList::iterator pIt2 = ::std::find(rInfo.Listener.begin(), rInfo.Listener.end(), pListener);
 352     if (pIt2 == rInfo.Listener.end())
 353         rInfo.Listener.push_back(pListener);
 354
 355     aReadLock.unlock();
 356     // <- SAFE ------------------------------
 357 }
 358
 359 //-----------------------------------------------
 360 void StorageHolder::removeStorageListener(      IStorageListener* pListener,
 361                                           const OUString&  sPath    )
 362 {
 363     OUString sNormedPath = StorageHolder::impl_st_normPath(sPath);
 364
 365     // SAFE -> ------------------------------
 366     ReadGuard aReadLock(m_aLock);
 367
 368     TPath2StorageInfo::iterator pIt1 = m_lStorages.find(sNormedPath);
 369     if (pIt1 == m_lStorages.end())
 370         return;
 371
 372     TStorageInfo& rInfo = pIt1->second;
 373     TStorageListenerList::iterator pIt2 = ::std::find(rInfo.Listener.begin(), rInfo.Listener.end(), pListener);
 374     if (pIt2 != rInfo.Listener.end())
 375         rInfo.Listener.erase(pIt2);
 376
 377     aReadLock.unlock();
 378     // <- SAFE ------------------------------
 379 }
 380
 381 //-----------------------------------------------
 382 OUString StorageHolder::getPathOfStorage(const css::uno::Reference< css::embed::XStorage >& xStorage)
 383 {
 384     // SAFE -> ------------------------------
 385     ReadGuard aReadLock(m_aLock);
 386
 387     TPath2StorageInfo::const_iterator pIt;
 388     for (  pIt  = m_lStorages.begin();
 389            pIt != m_lStorages.end()  ;
 390          ++pIt                       )
 391     {
 392         const TStorageInfo& rInfo = pIt->second;
 393         if (rInfo.Storage == xStorage)
 394             break;
 395     }
 396
 397     if (pIt == m_lStorages.end())
 398         return OUString();
 399
 400     return pIt->first;
 401
 402     // <- SAFE ------------------------------
 403 }
 404
 405 //-----------------------------------------------
 406 css::uno::Reference< css::embed::XStorage > StorageHolder::getParentStorage(const css::uno::Reference< css::embed::XStorage >& xChild)
 407 {
 408     OUString sChildPath = getPathOfStorage(xChild);
 409     return getParentStorage(sChildPath);
 410 }
 411
 412 //-----------------------------------------------
 413 css::uno::Reference< css::embed::XStorage > StorageHolder::getParentStorage(const OUString& sChildPath)
 414 {
 415     // normed path = "a/b/c/" ... we search for "a/b/"
 416     OUString sNormedPath = StorageHolder::impl_st_normPath(sChildPath);
 417     OUStringList    lFolders    = StorageHolder::impl_st_parsePath(sNormedPath);
 418     sal_Int32       c           = lFolders.size();
 419
 420     // a) ""       => -       => no parent
 421     // b) "a/b/c/" => "a/b/"  => return storage "a/b/"
 422     // c) "a/"     => ""      => return root !
 423
 424     // a)
 425     if (c < 1)
 426         return css::uno::Reference< css::embed::XStorage >();
 427
 428     // SAFE -> ----------------------------------
 429     ReadGuard aReadLock(m_aLock);
 430
 431     // b)
 432     if (c < 2)
 433         return m_xRoot;
 434
 435     // c)
 436     OUString sParentPath;
 437     sal_Int32       i = 0;
 438     for (i=0; i<c-1; ++i)
 439     {
 440         sParentPath += lFolders[i];
 441         sParentPath += PATH_SEPARATOR;
 442     }
 443
 444     TPath2StorageInfo::const_iterator pParent = m_lStorages.find(sParentPath);
 445     if (pParent != m_lStorages.end())
 446         return pParent->second.Storage;
 447
 448     aReadLock.unlock();
 449     // <- SAFE ----------------------------------
 450
 451     // ?
 452     LOG_WARNING("StorageHolder::getParentStorage()", "Unexpected situation. Cached storage item seems to be wrong.")
 453     return css::uno::Reference< css::embed::XStorage >();
 454 }
 455
 456 //-----------------------------------------------
 457 void StorageHolder::operator=(const StorageHolder& rCopy)
 458 {
 459     // SAFE -> ----------------------------------
 460     WriteGuard aWriteLock(m_aLock);
 461
 462     m_xRoot     = rCopy.m_xRoot;
 463     m_lStorages = rCopy.m_lStorages;
 464
 465     aWriteLock.unlock();
 466     // <- SAFE ----------------------------------
 467 }
 468
 469 //-----------------------------------------------
 470 css::uno::Reference< css::embed::XStorage > StorageHolder::openSubStorageWithFallback(const css::uno::Reference< css::embed::XStorage >& xBaseStorage  ,
 471                                                                                       const OUString&                             sSubStorage   ,
 472                                                                                             sal_Int32                                    eOpenMode     ,
 473                                                                                             sal_Bool                                     bAllowFallback)
 474 {
 475     // a) try it first with user specified open mode
 476     //    ignore errors ... but save it for later use!
 477     css::uno::Exception exResult;
 478     try
 479     {
 480         css::uno::Reference< css::embed::XStorage > xSubStorage = xBaseStorage->openStorageElement(sSubStorage, eOpenMode);
 481         if (xSubStorage.is())
 482             return xSubStorage;
 483     }
 484     catch(const css::uno::RuntimeException&)
 485         { throw; }
 486     catch(const css::uno::Exception& ex)
 487         { exResult = ex; }
 488
 489     // b) readonly already tried? => forward last error!
 490     if (
 491         (!bAllowFallback                                                                 ) ||   // fallback allowed  ?
 492         ((eOpenMode & css::embed::ElementModes::WRITE) != css::embed::ElementModes::WRITE)      // fallback possible ?
 493        )
 494         throw exResult;
 495
 496     // c) try it readonly
 497     //    dont catch exception here! Outside code whish to know, if operation failed or not.
 498     //    Otherwhise they work on NULL references ...
 499     sal_Int32 eNewMode = (eOpenMode & ~css::embed::ElementModes::WRITE);
 500     css::uno::Reference< css::embed::XStorage > xSubStorage = xBaseStorage->openStorageElement(sSubStorage, eNewMode);
 501     if (xSubStorage.is())
 502         return xSubStorage;
 503
 504     // d) no chance!
 505     LOG_WARNING("openSubStorageWithFallback()", "Unexpected situation! Got no exception for missing storage ...")
 506     return css::uno::Reference< css::embed::XStorage >();
 507 }
 508
 509 //-----------------------------------------------
 510 css::uno::Reference< css::io::XStream > StorageHolder::openSubStreamWithFallback(const css::uno::Reference< css::embed::XStorage >& xBaseStorage  ,
 511                                                                                  const OUString&                             sSubStream    ,
 512                                                                                        sal_Int32                                    eOpenMode     ,
 513                                                                                        sal_Bool                                     bAllowFallback)
 514 {
 515     // a) try it first with user specified open mode
 516     //    ignore errors ... but save it for later use!
 517     css::uno::Exception exResult;
 518     try
 519     {
 520         css::uno::Reference< css::io::XStream > xSubStream = xBaseStorage->openStreamElement(sSubStream, eOpenMode);
 521         if (xSubStream.is())
 522             return xSubStream;
 523     }
 524     catch(const css::uno::RuntimeException&)
 525         { throw; }
 526     catch(const css::uno::Exception& ex)
 527         { exResult = ex; }
 528
 529     // b) readonly already tried? => forward last error!
 530     if (
 531         (!bAllowFallback                                                                 ) ||   // fallback allowed  ?
 532         ((eOpenMode & css::embed::ElementModes::WRITE) != css::embed::ElementModes::WRITE)      // fallback possible ?
 533        )
 534         throw exResult;
 535
 536     // c) try it readonly
 537     //    dont catch exception here! Outside code whish to know, if operation failed or not.
 538     //    Otherwhise they work on NULL references ...
 539     sal_Int32 eNewMode = (eOpenMode & ~css::embed::ElementModes::WRITE);
 540     css::uno::Reference< css::io::XStream > xSubStream = xBaseStorage->openStreamElement(sSubStream, eNewMode);
 541     if (xSubStream.is())
 542         return xSubStream;
 543
 544     // d) no chance!
 545     LOG_WARNING("openSubStreamWithFallbacks()", "Unexpected situation! Got no exception for missing stream ...")
 546     return css::uno::Reference< css::io::XStream >();
 547 }
 548
 549 //-----------------------------------------------
 550 OUString StorageHolder::impl_st_normPath(const OUString& sPath)
 551 {
 552     // path must start without "/" but end with "/"!
 553
 554     OUString sNormedPath = sPath;
 555
 556     // "/bla" => "bla" && "/" => "" (!)
 557     if (sNormedPath.indexOf(PATH_SEPARATOR) == 0)
 558         sNormedPath += sNormedPath.copy(1);
 559
 560     // "/" => "" || "" => "" ?
 561     if (sNormedPath.isEmpty())
 562         return OUString();
 563
 564     // "bla" => "bla/"
 565     if (sNormedPath.lastIndexOf(PATH_SEPARATOR) != (sNormedPath.getLength()-1))
 566         sNormedPath += PATH_SEPARATOR;
 567
 568     return sNormedPath;
 569 }
 570
 571 //-----------------------------------------------
 572 OUStringList StorageHolder::impl_st_parsePath(const OUString& sPath)
 573 {
 574     OUStringList lToken;
 575     sal_Int32    i  = 0;
 576     while (true)
 577     {
 578         OUString sToken = sPath.getToken(0, PATH_SEPARATOR_UNICODE, i);
 579         if (i < 0)
 580             break;
 581         lToken.push_back(sToken);
 582     }
 583     return lToken;
 584 }
 585
 586 //===============================================
 587 } // namespace framework
 588
 589 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */