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