package/source/xstor/ohierarchyholder.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/io/IOException.hpp>
  23 #include <com/sun/star/uno/Reference.hxx>
  24 #include <com/sun/star/embed/ElementModes.hpp>
  25 #include <com/sun/star/embed/XHierarchicalStorageAccess2.hpp>
  26 #include <com/sun/star/embed/XTransactedObject.hpp>
  27 #include <com/sun/star/embed/XTransactionBroadcaster.hpp>
  28 #include <com/sun/star/lang/IllegalArgumentException.hpp>
  29 #include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
  30 #include <cppuhelper/exc_hlp.hxx>
  31 #include <o3tl/string_view.hxx>
  32
  33 #include "ohierarchyholder.hxx"
  34 #include "xstorage.hxx"
  35
  36 using namespace ::com::sun::star;
  37
  38 // OHierarchyHolder_Impl
  39
  40 uno::Reference< embed::XExtendedStorageStream > OHierarchyHolder_Impl::GetStreamHierarchically( sal_Int32 nStorageMode, std::vector<OUString>& aListPath, sal_Int32 nStreamMode, const ::comphelper::SequenceAsHashMap& aEncryptionData )
  41 {
  42     if ( !( nStorageMode & embed::ElementModes::WRITE ) && ( nStreamMode & embed::ElementModes::WRITE ) )
  43         throw io::IOException(u"invalid storage/stream mode combo"_ustr);
  44
  45     uno::Reference< embed::XExtendedStorageStream > xResult =
  46         m_xChild->GetStreamHierarchically( nStorageMode, aListPath, nStreamMode, aEncryptionData );
  47     if ( !xResult.is() )
  48         throw uno::RuntimeException();
  49
  50     return xResult;
  51 }
  52
  53 void OHierarchyHolder_Impl::RemoveStreamHierarchically( std::vector<OUString>& aListPath )
  54 {
  55     m_xChild->RemoveStreamHierarchically( aListPath );
  56 }
  57
  58 // static
  59 std::vector<OUString> OHierarchyHolder_Impl::GetListPathFromString( std::u16string_view aPath )
  60 {
  61     std::vector<OUString> aResult;
  62     sal_Int32 nIndex = 0;
  63     do
  64     {
  65         OUString aName( o3tl::getToken(aPath, 0, '/', nIndex ) );
  66         if ( aName.isEmpty() )
  67             throw lang::IllegalArgumentException();
  68
  69         aResult.push_back( aName );
  70     }
  71     while ( nIndex >= 0 );
  72
  73     return aResult;
  74 }
  75
  76 // OHierarchyElement_Impl
  77
  78 uno::Reference< embed::XExtendedStorageStream > OHierarchyElement_Impl::GetStreamHierarchically( sal_Int32 nStorageMode, std::vector<OUString>& aListPath, sal_Int32 nStreamMode, const ::comphelper::SequenceAsHashMap& aEncryptionData )
  79 {
  80     std::unique_lock aGuard( m_aMutex );
  81
  82     if ( !( nStorageMode & embed::ElementModes::WRITE ) && ( nStreamMode & embed::ElementModes::WRITE ) )
  83         throw io::IOException(u"invalid storage/stream mode combo"_ustr);
  84
  85     if ( aListPath.empty() )
  86         throw uno::RuntimeException();
  87
  88     OUString aNextName = *(aListPath.begin());
  89     aListPath.erase( aListPath.begin() );
  90
  91     uno::Reference< embed::XExtendedStorageStream > xResult;
  92
  93     rtl::Reference< OStorage > xOwnStor = m_xOwnStorage.is() ? m_xOwnStorage
  94                 : m_xWeakOwnStorage.get();
  95     if (!xOwnStor)
  96         throw uno::RuntimeException(u"no own storage"_ustr);
  97
  98     if ( aListPath.empty() )
  99     {
 100         if ( aEncryptionData.empty() )
 101             xResult = xOwnStor->openStreamElementByHierarchicalName( aNextName, nStreamMode );
 102         else
 103             xResult = xOwnStor->openEncryptedStreamByHierarchicalName( aNextName, nStreamMode, aEncryptionData.getAsConstNamedValueList() );
 104
 105         uno::Reference< embed::XTransactedObject > xTransact( xResult, uno::UNO_QUERY );
 106         if ( xTransact.is() )
 107         {
 108             // the existence of the transacted object means that the stream is opened for writing also
 109             // so the whole chain must be committed
 110             uno::Reference< embed::XTransactionBroadcaster > xTrBroadcast( xTransact, uno::UNO_QUERY_THROW );
 111             xTrBroadcast->addTransactionListener( static_cast< embed::XTransactionListener* >( this ) );
 112         }
 113         else
 114         {
 115             uno::Reference< lang::XComponent > xStreamComp( xResult, uno::UNO_QUERY_THROW );
 116             xStreamComp->addEventListener( static_cast< lang::XEventListener* >( this ) );
 117         }
 118
 119         m_aOpenStreams.emplace_back( xResult );
 120     }
 121     else
 122     {
 123         bool bNewElement = false;
 124         ::rtl::Reference< OHierarchyElement_Impl > aElement;
 125         OHierarchyElementList_Impl::iterator aIter = m_aChildren.find( aNextName );
 126         if ( aIter != m_aChildren.end() )
 127             aElement = aIter->second;
 128
 129         if ( !aElement.is() )
 130         {
 131             bNewElement = true;
 132             rtl::Reference< OStorage > xChildStorage = xOwnStor->openStorageElement2( aNextName, nStorageMode );
 133             if ( !xChildStorage.is() )
 134                 throw uno::RuntimeException();
 135
 136             aElement = new OHierarchyElement_Impl( xChildStorage );
 137         }
 138
 139         xResult = aElement->GetStreamHierarchically( nStorageMode, aListPath, nStreamMode, aEncryptionData );
 140         if ( !xResult.is() )
 141             throw uno::RuntimeException();
 142
 143         if ( bNewElement )
 144         {
 145             m_aChildren[aNextName] = aElement;
 146             aElement->SetParent( this );
 147         }
 148     }
 149
 150     // the subelement was opened successfully, remember the storage to let it be locked
 151     m_xOwnStorage = std::move(xOwnStor);
 152
 153     return xResult;
 154 }
 155
 156 void OHierarchyElement_Impl::RemoveStreamHierarchically( std::vector<OUString>& aListPath )
 157 {
 158     std::unique_lock aGuard( m_aMutex );
 159
 160     if ( aListPath.empty() )
 161         throw uno::RuntimeException();
 162
 163     OUString aNextName = *(aListPath.begin());
 164     aListPath.erase( aListPath.begin() );
 165
 166     rtl::Reference< OStorage > xOwnStor = m_xOwnStorage.is() ? m_xOwnStorage
 167                 : m_xWeakOwnStorage.get();
 168     if (!xOwnStor)
 169         throw uno::RuntimeException(u"no own storage"_ustr);
 170
 171     if ( aListPath.empty() )
 172     {
 173         xOwnStor->removeElement( aNextName );
 174     }
 175     else
 176     {
 177         ::rtl::Reference< OHierarchyElement_Impl > aElement;
 178         OHierarchyElementList_Impl::iterator aIter = m_aChildren.find( aNextName );
 179         if ( aIter != m_aChildren.end() )
 180             aElement = aIter->second;
 181
 182         if ( !aElement.is() )
 183         {
 184             rtl::Reference< OStorage > xChildStorage = xOwnStor->openStorageElement2( aNextName,
 185                                                                                             embed::ElementModes::READWRITE );
 186             if ( !xChildStorage.is() )
 187                 throw uno::RuntimeException();
 188
 189             aElement = new OHierarchyElement_Impl( xChildStorage );
 190         }
 191
 192         aElement->RemoveStreamHierarchically( aListPath );
 193     }
 194
 195     xOwnStor->commit();
 196
 197     TestForClosing();
 198 }
 199
 200 void OHierarchyElement_Impl::Commit()
 201 {
 202     ::rtl::Reference< OHierarchyElement_Impl > xKeepAlive( this );
 203     ::rtl::Reference< OHierarchyElement_Impl > aParent;
 204     rtl::Reference<OStorage> xOwnStor;
 205
 206     {
 207         std::unique_lock aGuard( m_aMutex );
 208         aParent = m_rParent;
 209         xOwnStor = m_xOwnStorage;
 210     }
 211
 212     if ( xOwnStor.is() )
 213     {
 214         xOwnStor->commit();
 215         if ( aParent.is() )
 216             aParent->Commit();
 217     }
 218 }
 219
 220 void OHierarchyElement_Impl::TestForClosing()
 221 {
 222     ::rtl::Reference< OHierarchyElement_Impl > xKeepAlive( this );
 223     {
 224         std::unique_lock aGuard( m_aMutex );
 225
 226         if ( m_aOpenStreams.empty() && m_aChildren.empty() )
 227         {
 228             if ( m_rParent.is() )
 229             {
 230                 // only the root storage should not be disposed, other storages can be disposed
 231                 if ( m_xOwnStorage.is() )
 232                 {
 233                     try
 234                     {
 235                         m_xOwnStorage->dispose();
 236                     }
 237                     catch( uno::Exception& )
 238                     {}
 239                 }
 240
 241                 m_rParent->RemoveElement( this );
 242             }
 243
 244             m_xOwnStorage.clear();
 245         }
 246     }
 247 }
 248
 249 void SAL_CALL OHierarchyElement_Impl::disposing( const lang::EventObject& Source )
 250 {
 251     try
 252     {
 253         {
 254             std::unique_lock aGuard(m_aMutex);
 255             uno::Reference< embed::XExtendedStorageStream > xStream(Source.Source, uno::UNO_QUERY);
 256
 257             std::erase_if(m_aOpenStreams,
 258                 [&xStream](const OWeakStorRefVector_Impl::value_type& rxStorage) {
 259                 return !rxStorage.get().is() || rxStorage.get() == xStream; });
 260         }
 261
 262         TestForClosing();
 263     }
 264     catch( uno::Exception& ex )
 265     {
 266         css::uno::Any anyEx = cppu::getCaughtException();
 267         throw lang::WrappedTargetRuntimeException( ex.Message,
 268                         nullptr, anyEx ); // no exception must happen here, usually an exception means disaster
 269     }
 270 }
 271
 272 void OHierarchyElement_Impl::RemoveElement( const ::rtl::Reference< OHierarchyElement_Impl >& aRef )
 273 {
 274     {
 275         std::unique_lock aGuard( m_aMutex );
 276         OHierarchyElementList_Impl::iterator aIter = m_aChildren.begin();
 277         while (aIter != m_aChildren.end())
 278         {
 279             if (aIter->second == aRef )
 280                 aIter = m_aChildren.erase(aIter);
 281             else
 282                 ++aIter;
 283         }
 284     }
 285
 286     TestForClosing();
 287 }
 288
 289 // XTransactionListener
 290 void SAL_CALL OHierarchyElement_Impl::preCommit( const css::lang::EventObject& /*aEvent*/ )
 291 {
 292 }
 293
 294 void SAL_CALL OHierarchyElement_Impl::commited( const css::lang::EventObject& /*aEvent*/ )
 295 {
 296     try
 297     {
 298         Commit();
 299     }
 300     catch( const uno::Exception& )
 301     {
 302         css::uno::Any anyEx = cppu::getCaughtException();
 303         throw lang::WrappedTargetRuntimeException(
 304                             u"Can not commit storage sequence!"_ustr,
 305                             uno::Reference< uno::XInterface >(),
 306                             anyEx );
 307     }
 308 }
 309
 310 void SAL_CALL OHierarchyElement_Impl::preRevert( const css::lang::EventObject& /*aEvent*/ )
 311 {
 312 }
 313
 314 void SAL_CALL OHierarchyElement_Impl::reverted( const css::lang::EventObject& /*aEvent*/ )
 315 {
 316 }
 317
 318 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */