sot/source/unoolestorage/xolesimplestorage.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/lang/DisposedException.hpp>
  21 #include <com/sun/star/io/XStream.hpp>
  22 #include <com/sun/star/io/XInputStream.hpp>
  23 #include <com/sun/star/io/XSeekable.hpp>
  24 #include <com/sun/star/io/XTruncate.hpp>
  25 #include <com/sun/star/io/TempFile.hpp>
  26
  27 #include <comphelper/processfactory.hxx>
  28 #include <comphelper/storagehelper.hxx>
  29
  30 #include <unotools/ucbstreamhelper.hxx>
  31
  32 #include <cppuhelper/exc_hlp.hxx>
  33
  34 #include <sot/storinfo.hxx>
  35
  36 #include "xolesimplestorage.hxx"
  37
  38
  39 using namespace ::com::sun::star;
  40
  41 const sal_Int32 nBytesCount = 32000;
  42
  43
  44 // --------------------------------------------------------------------------------
  45 OLESimpleStorage::OLESimpleStorage( uno::Reference< lang::XMultiServiceFactory > xFactory )
  46 : m_bDisposed( sal_False )
  47 , m_pStream( NULL )
  48 , m_pStorage( NULL )
  49 , m_pListenersContainer( NULL )
  50 , m_xFactory( xFactory )
  51 , m_bNoTemporaryCopy( sal_False )
  52 {
  53     OSL_ENSURE( m_xFactory.is(), "No factory is provided on creation!\n" );
  54     if ( !m_xFactory.is() )
  55         throw uno::RuntimeException();
  56 }
  57
  58 // --------------------------------------------------------------------------------
  59 OLESimpleStorage::~OLESimpleStorage()
  60 {
  61     try {
  62         m_refCount++;
  63         dispose();
  64     } catch( uno::Exception& )
  65     {}
  66
  67     if ( m_pListenersContainer )
  68     {
  69         delete m_pListenersContainer;
  70         m_pListenersContainer = NULL;
  71     }
  72 }
  73
  74 //-------------------------------------------------------------------------
  75 uno::Sequence< OUString > SAL_CALL OLESimpleStorage::impl_staticGetSupportedServiceNames()
  76 {
  77     uno::Sequence< OUString > aRet(1);
  78     aRet[0] = OUString("com.sun.star.embed.OLESimpleStorage");
  79     return aRet;
  80 }
  81
  82 //-------------------------------------------------------------------------
  83 OUString SAL_CALL OLESimpleStorage::impl_staticGetImplementationName()
  84 {
  85     return OUString("com.sun.star.comp.embed.OLESimpleStorage");
  86 }
  87
  88 //-------------------------------------------------------------------------
  89 uno::Reference< uno::XInterface > SAL_CALL OLESimpleStorage::impl_staticCreateSelfInstance(
  90             const uno::Reference< lang::XMultiServiceFactory >& xServiceManager )
  91 {
  92     return uno::Reference< uno::XInterface >( *new OLESimpleStorage( xServiceManager ) );
  93 }
  94
  95 //-------------------------------------------------------------------------
  96 void OLESimpleStorage::UpdateOriginal_Impl()
  97 {
  98     if ( !m_bNoTemporaryCopy )
  99     {
 100         uno::Reference< io::XSeekable > xSeek( m_xStream, uno::UNO_QUERY_THROW );
 101         xSeek->seek( 0 );
 102
 103         uno::Reference< io::XSeekable > xTempSeek( m_xTempStream, uno::UNO_QUERY_THROW );
 104         sal_Int64 nPos = xTempSeek->getPosition();
 105         xTempSeek->seek( 0 );
 106
 107         uno::Reference< io::XInputStream > xTempInp = m_xTempStream->getInputStream();
 108         uno::Reference< io::XOutputStream > xOutputStream = m_xStream->getOutputStream();
 109         if ( !xTempInp.is() || !xOutputStream.is() )
 110             throw uno::RuntimeException();
 111
 112         uno::Reference< io::XTruncate > xTrunc( xOutputStream, uno::UNO_QUERY_THROW );
 113         xTrunc->truncate();
 114
 115         ::comphelper::OStorageHelper::CopyInputToOutput( xTempInp, xOutputStream );
 116         xOutputStream->flush();
 117         xTempSeek->seek( nPos );
 118     }
 119 }
 120
 121 //-------------------------------------------------------------------------
 122 void OLESimpleStorage::InsertInputStreamToStorage_Impl( BaseStorage* pStorage, OUString aName, const uno::Reference< io::XInputStream >& xInputStream )
 123     throw ( uno::Exception )
 124 {
 125     if ( !pStorage || aName.isEmpty() || !xInputStream.is() )
 126         throw uno::RuntimeException();
 127
 128     if ( pStorage->IsContained( aName ) )
 129         throw container::ElementExistException(); // TODO:
 130
 131     BaseStorageStream* pNewStream = pStorage->OpenStream( aName );
 132     if ( !pNewStream || pNewStream->GetError() || pStorage->GetError() )
 133     {
 134         if ( pNewStream )
 135             DELETEZ( pNewStream );
 136         pStorage->ResetError();
 137         throw io::IOException(); // TODO
 138     }
 139
 140     try
 141     {
 142         uno::Sequence< sal_Int8 > aData( nBytesCount );
 143         sal_Int32 nRead = 0;
 144         do
 145         {
 146             nRead = xInputStream->readBytes( aData, nBytesCount );
 147             if ( nRead < nBytesCount )
 148                 aData.realloc( nRead );
 149
 150             sal_Int32 nWritten = pNewStream->Write( aData.getArray(), nRead );
 151             if ( nWritten < nRead )
 152                 throw io::IOException();
 153         } while( nRead == nBytesCount );
 154     }
 155     catch( uno::Exception& )
 156     {
 157         DELETEZ( pNewStream );
 158         pStorage->Remove( aName );
 159
 160         throw;
 161     }
 162
 163     DELETEZ( pNewStream );
 164 }
 165
 166 //-------------------------------------------------------------------------
 167 void OLESimpleStorage::InsertNameAccessToStorage_Impl( BaseStorage* pStorage, OUString aName, const uno::Reference< container::XNameAccess >& xNameAccess )
 168     throw ( uno::Exception )
 169 {
 170     if ( !pStorage || aName.isEmpty() || !xNameAccess.is() )
 171         throw uno::RuntimeException();
 172
 173     if ( pStorage->IsContained( aName ) )
 174         throw container::ElementExistException(); // TODO:
 175
 176     BaseStorage* pNewStorage = pStorage->OpenStorage( aName );
 177     if ( !pNewStorage || pNewStorage->GetError() || pStorage->GetError() )
 178     {
 179         if ( pNewStorage )
 180             DELETEZ( pNewStorage );
 181         pStorage->ResetError();
 182         throw io::IOException(); // TODO
 183     }
 184
 185     try
 186     {
 187         uno::Sequence< OUString > aElements = xNameAccess->getElementNames();
 188         for ( sal_Int32 nInd = 0; nInd < aElements.getLength(); nInd++ )
 189         {
 190             uno::Reference< io::XInputStream > xInputStream;
 191             uno::Reference< container::XNameAccess > xSubNameAccess;
 192             uno::Any aAny = xNameAccess->getByName( aElements[nInd] );
 193             if ( aAny >>= xInputStream )
 194                 InsertInputStreamToStorage_Impl( pNewStorage, aElements[nInd], xInputStream );
 195             else if ( aAny >>= xSubNameAccess )
 196                 InsertNameAccessToStorage_Impl( pNewStorage, aElements[nInd], xSubNameAccess );
 197         }
 198     }
 199     catch( uno::Exception& )
 200     {
 201         DELETEZ( pNewStorage );
 202         pStorage->Remove( aName );
 203
 204         throw;
 205     }
 206
 207     DELETEZ( pNewStorage );
 208 }
 209
 210 //____________________________________________________________________________________________________
 211 //  XInitialization
 212 //____________________________________________________________________________________________________
 213
 214 void SAL_CALL OLESimpleStorage::initialize( const uno::Sequence< uno::Any >& aArguments )
 215         throw ( uno::Exception,
 216                 uno::RuntimeException)
 217 {
 218     if ( m_pStream || m_pStorage )
 219         throw io::IOException(); // TODO: already initilized
 220
 221     sal_Int32 nArgNum = aArguments.getLength();
 222     OSL_ENSURE( nArgNum >= 1 && nArgNum <= 2, "Wrong parameter number" );
 223
 224     if ( nArgNum < 1 || nArgNum > 2 )
 225         throw lang::IllegalArgumentException(); // TODO:
 226
 227     uno::Reference< io::XStream > xStream;
 228     uno::Reference< io::XInputStream > xInputStream;
 229     if ( !( aArguments[0] >>= xStream ) && !( aArguments[0] >>= xInputStream ) )
 230         throw lang::IllegalArgumentException(); // TODO:
 231
 232     if ( nArgNum == 2 )
 233     {
 234         if ( !( aArguments[1] >>= m_bNoTemporaryCopy ) )
 235             throw lang::IllegalArgumentException(); // TODO:
 236     }
 237
 238     if ( m_bNoTemporaryCopy )
 239     {
 240         // TODO: ???
 241         // If the temporary stream is not created, the original stream must be wrapped
 242         // since SvStream wrapper closes the stream is owns
 243         if ( xInputStream.is() )
 244         {
 245             // the stream must be seekable for direct access
 246             uno::Reference< io::XSeekable > xSeek( xInputStream, uno::UNO_QUERY_THROW );
 247             m_pStream = ::utl::UcbStreamHelper::CreateStream( xInputStream, sal_False );
 248         }
 249         else if ( xStream.is() )
 250         {
 251             // the stream must be seekable for direct access
 252             uno::Reference< io::XSeekable > xSeek( xStream, uno::UNO_QUERY_THROW );
 253             m_pStream = ::utl::UcbStreamHelper::CreateStream( xStream, sal_False );
 254         }
 255         else
 256             throw lang::IllegalArgumentException(); // TODO:
 257     }
 258     else
 259     {
 260         uno::Reference < io::XStream > xTempFile(
 261                 io::TempFile::create(comphelper::getComponentContext(m_xFactory)),
 262                 uno::UNO_QUERY_THROW );
 263         uno::Reference < io::XSeekable > xTempSeek( xTempFile, uno::UNO_QUERY_THROW );
 264         uno::Reference< io::XOutputStream > xTempOut = xTempFile->getOutputStream();
 265         if ( !xTempOut.is() )
 266             throw uno::RuntimeException();
 267
 268         if ( xInputStream.is() )
 269         {
 270             try
 271             {
 272                 uno::Reference< io::XSeekable > xSeek( xInputStream, uno::UNO_QUERY_THROW );
 273                 xSeek->seek( 0 );
 274             }
 275             catch( uno::Exception& )
 276             {}
 277
 278             ::comphelper::OStorageHelper::CopyInputToOutput( xInputStream, xTempOut );
 279             xTempOut->closeOutput();
 280             xTempSeek->seek( 0 );
 281             uno::Reference< io::XInputStream > xTempInput = xTempFile->getInputStream();
 282             m_pStream = ::utl::UcbStreamHelper::CreateStream( xTempInput, sal_False );
 283         }
 284         else if ( xStream.is() )
 285         {
 286             // not sure that the storage flashes the stream on commit
 287             m_xStream = xStream;
 288             m_xTempStream = xTempFile;
 289
 290             uno::Reference< io::XSeekable > xSeek( xStream, uno::UNO_QUERY_THROW );
 291             xSeek->seek( 0 );
 292             uno::Reference< io::XInputStream > xInpStream = xStream->getInputStream();
 293             if ( !xInpStream.is() || !xStream->getOutputStream().is() )
 294                 throw uno::RuntimeException();
 295
 296             ::comphelper::OStorageHelper::CopyInputToOutput( xInpStream, xTempOut );
 297             xTempOut->flush();
 298             xTempSeek->seek( 0 );
 299
 300             m_pStream = ::utl::UcbStreamHelper::CreateStream( xTempFile, sal_False );
 301         }
 302         else
 303             throw lang::IllegalArgumentException(); // TODO:
 304     }
 305
 306     if ( !m_pStream || m_pStream->GetError() )
 307         throw io::IOException(); // TODO
 308
 309     m_pStorage = new Storage( *m_pStream, sal_False );
 310 }
 311
 312
 313 //____________________________________________________________________________________________________
 314 //  XNameContainer
 315 //____________________________________________________________________________________________________
 316
 317 // --------------------------------------------------------------------------------
 318 void SAL_CALL OLESimpleStorage::insertByName( const OUString& aName, const uno::Any& aElement )
 319         throw ( lang::IllegalArgumentException,
 320                 container::ElementExistException,
 321                 lang::WrappedTargetException,
 322                 uno::RuntimeException)
 323 {
 324     ::osl::MutexGuard aGuard( m_aMutex );
 325
 326     if ( m_bDisposed )
 327         throw lang::DisposedException();
 328
 329       if ( !m_pStorage )
 330         throw uno::RuntimeException();
 331
 332     uno::Reference< io::XStream > xStream;
 333     uno::Reference< io::XInputStream > xInputStream;
 334     uno::Reference< container::XNameAccess > xNameAccess;
 335
 336     try
 337     {
 338         if ( !m_bNoTemporaryCopy && !m_xStream.is() )
 339             throw io::IOException(); // TODO
 340
 341         if ( aElement >>= xStream )
 342             xInputStream = xStream->getInputStream();
 343         else if ( !( aElement >>= xInputStream ) && !( aElement >>= xNameAccess ) )
 344             throw lang::IllegalArgumentException(); // TODO:
 345
 346         if ( xInputStream.is() )
 347             InsertInputStreamToStorage_Impl( m_pStorage, aName, xInputStream );
 348         else if ( xNameAccess.is() )
 349             InsertNameAccessToStorage_Impl( m_pStorage, aName, xNameAccess );
 350         else
 351             throw uno::RuntimeException();
 352     }
 353     catch( uno::RuntimeException& )
 354     {
 355         throw;
 356     }
 357     catch( container::ElementExistException& )
 358     {
 359         throw;
 360     }
 361     catch( const uno::Exception& e )
 362     {
 363         throw lang::WrappedTargetException( OUString(  "Insert has failed!"  ),
 364                                             uno::Reference< uno::XInterface >(),
 365                                             uno::makeAny( e ) );
 366     }
 367 }
 368
 369 // --------------------------------------------------------------------------------
 370 void SAL_CALL OLESimpleStorage::removeByName( const OUString& aName )
 371         throw ( container::NoSuchElementException,
 372                 lang::WrappedTargetException,
 373                 uno::RuntimeException)
 374 {
 375     ::osl::MutexGuard aGuard( m_aMutex );
 376
 377     if ( m_bDisposed )
 378         throw lang::DisposedException();
 379
 380       if ( !m_pStorage )
 381         throw uno::RuntimeException();
 382
 383     if ( !m_bNoTemporaryCopy && !m_xStream.is() )
 384         throw lang::WrappedTargetException(); // io::IOException(); // TODO
 385
 386     if ( !m_pStorage->IsContained( aName ) )
 387         throw container::NoSuchElementException(); // TODO:
 388
 389     m_pStorage->Remove( aName );
 390
 391     if ( m_pStorage->GetError() )
 392     {
 393         m_pStorage->ResetError();
 394         throw lang::WrappedTargetException(); // io::IOException(); // TODO
 395     }
 396 }
 397
 398 // --------------------------------------------------------------------------------
 399 void SAL_CALL OLESimpleStorage::replaceByName( const OUString& aName, const uno::Any& aElement )
 400         throw ( lang::IllegalArgumentException,
 401                 container::NoSuchElementException,
 402                 lang::WrappedTargetException,
 403                 uno::RuntimeException)
 404 {
 405     ::osl::MutexGuard aGuard( m_aMutex );
 406
 407     if ( m_bDisposed )
 408         throw lang::DisposedException();
 409
 410     removeByName( aName );
 411
 412     try
 413     {
 414         insertByName( aName, aElement );
 415     }
 416     catch( container::ElementExistException& )
 417     {
 418            uno::Any aCaught( ::cppu::getCaughtException() );
 419
 420         throw lang::WrappedTargetException( OUString("Can't copy raw stream"),
 421                                             uno::Reference< uno::XInterface >(),
 422                                             aCaught );
 423     }
 424 }
 425
 426 // --------------------------------------------------------------------------------
 427 uno::Any SAL_CALL OLESimpleStorage::getByName( const OUString& aName )
 428         throw ( container::NoSuchElementException,
 429                 lang::WrappedTargetException,
 430                 uno::RuntimeException )
 431 {
 432     ::osl::MutexGuard aGuard( m_aMutex );
 433
 434     if ( m_bDisposed )
 435         throw lang::DisposedException();
 436
 437       if ( !m_pStorage )
 438         throw uno::RuntimeException();
 439
 440     if ( !m_pStorage->IsContained( aName ) )
 441         throw container::NoSuchElementException(); // TODO:
 442
 443     uno::Any aResult;
 444
 445     uno::Reference< io::XStream > xTempFile(
 446         io::TempFile::create(comphelper::getComponentContext(m_xFactory)),
 447         uno::UNO_QUERY );
 448     uno::Reference< io::XSeekable > xSeekable( xTempFile, uno::UNO_QUERY_THROW );
 449     uno::Reference< io::XOutputStream > xOutputStream = xTempFile->getOutputStream();
 450     uno::Reference< io::XInputStream > xInputStream = xTempFile->getInputStream();
 451     if ( !xOutputStream.is() || !xInputStream.is() )
 452         throw uno::RuntimeException();
 453
 454     if ( m_pStorage->IsStorage( aName ) )
 455     {
 456         BaseStorage* pStrg = m_pStorage->OpenStorage( aName );
 457         m_pStorage->ResetError();
 458         if ( !pStrg )
 459             throw io::IOException();
 460
 461         SvStream* pStream = ::utl::UcbStreamHelper::CreateStream( xTempFile, sal_False ); // do not close the original stream
 462         if ( !pStream )
 463             throw uno::RuntimeException();
 464
 465         BaseStorage* pNewStor = new Storage( *pStream, sal_False );
 466         sal_Bool bSuccess =
 467             ( pStrg->CopyTo( pNewStor ) && pNewStor->Commit() && !pNewStor->GetError() && !pStrg->GetError() );
 468
 469         DELETEZ( pNewStor );
 470         DELETEZ( pStrg );
 471         DELETEZ( pStream );
 472
 473         if ( !bSuccess )
 474             throw uno::RuntimeException();
 475
 476         uno::Sequence< uno::Any > aArgs( 2 );
 477         aArgs[0] <<= xInputStream; // allow readonly access only
 478         aArgs[1] <<= (sal_Bool)sal_True; // do not create copy
 479
 480         uno::Reference< container::XNameContainer > xResultNameContainer(
 481             m_xFactory->createInstanceWithArguments(
 482                     OUString("com.sun.star.embed.OLESimpleStorage"),
 483                     aArgs ),
 484             uno::UNO_QUERY_THROW );
 485
 486         aResult <<= xResultNameContainer;
 487     }
 488     else
 489     {
 490         BaseStorageStream* pStream = m_pStorage->OpenStream( aName, STREAM_READ | STREAM_SHARE_DENYALL | STREAM_NOCREATE );
 491         if ( !pStream || pStream->GetError() || m_pStorage->GetError() )
 492         {
 493             m_pStorage->ResetError();
 494             DELETEZ( pStream );
 495             throw io::IOException(); // TODO
 496         }
 497
 498         try
 499         {
 500             uno::Sequence< sal_Int8 > aData( nBytesCount );
 501             sal_Int32 nSize = nBytesCount;
 502             sal_Int32 nRead = 0;
 503             while( 0 != ( nRead = pStream->Read( aData.getArray(), nSize ) ) )
 504             {
 505                 if ( nRead < nSize )
 506                 {
 507                     nSize = nRead;
 508                     aData.realloc( nSize );
 509                 }
 510
 511                 xOutputStream->writeBytes( aData );
 512             }
 513
 514             if ( pStream->GetError() )
 515                 throw io::IOException(); // TODO
 516
 517             xOutputStream->closeOutput();
 518             xSeekable->seek( 0 );
 519         }
 520         catch( uno::RuntimeException& )
 521         {
 522             DELETEZ( pStream );
 523             throw;
 524         }
 525         catch( uno::Exception& )
 526         {
 527             DELETEZ( pStream );
 528             throw lang::WrappedTargetException(); // TODO:
 529         }
 530
 531         DELETEZ( pStream );
 532
 533         aResult <<= xInputStream;
 534     }
 535
 536     return aResult;
 537 }
 538
 539 // --------------------------------------------------------------------------------
 540 uno::Sequence< OUString > SAL_CALL OLESimpleStorage::getElementNames()
 541         throw ( uno::RuntimeException )
 542 {
 543     ::osl::MutexGuard aGuard( m_aMutex );
 544
 545     if ( m_bDisposed )
 546         throw lang::DisposedException();
 547
 548       if ( !m_pStorage )
 549         throw uno::RuntimeException();
 550
 551     SvStorageInfoList aList;
 552     m_pStorage->FillInfoList( &aList );
 553
 554     if ( m_pStorage->GetError() )
 555     {
 556         m_pStorage->ResetError();
 557         throw uno::RuntimeException(); // TODO:
 558     }
 559
 560     uno::Sequence< OUString > aSeq( aList.size() );
 561     for ( sal_uInt32 nInd = 0; nInd < aList.size(); nInd++ )
 562         aSeq[nInd] = aList[nInd].GetName();
 563
 564     return aSeq;
 565 }
 566
 567 // --------------------------------------------------------------------------------
 568 sal_Bool SAL_CALL OLESimpleStorage::hasByName( const OUString& aName )
 569         throw ( uno::RuntimeException )
 570 {
 571     ::osl::MutexGuard aGuard( m_aMutex );
 572
 573     if ( m_bDisposed )
 574         throw lang::DisposedException();
 575
 576      if ( !m_pStorage )
 577         throw uno::RuntimeException();
 578
 579     sal_Bool bResult = m_pStorage->IsContained( aName );
 580
 581     if ( m_pStorage->GetError() )
 582     {
 583         m_pStorage->ResetError();
 584         throw uno::RuntimeException(); // TODO:
 585     }
 586
 587     return bResult;
 588 }
 589
 590 // --------------------------------------------------------------------------------
 591 uno::Type SAL_CALL OLESimpleStorage::getElementType()
 592         throw ( uno::RuntimeException )
 593 {
 594     ::osl::MutexGuard aGuard( m_aMutex );
 595
 596     if ( m_bDisposed )
 597         throw lang::DisposedException();
 598
 599     return getCppuType( (const uno::Reference< io::XInputStream >*)NULL );
 600 }
 601
 602 // --------------------------------------------------------------------------------
 603 sal_Bool SAL_CALL OLESimpleStorage::hasElements()
 604         throw ( uno::RuntimeException )
 605 {
 606     ::osl::MutexGuard aGuard( m_aMutex );
 607
 608     if ( m_bDisposed )
 609         throw lang::DisposedException();
 610
 611       if ( !m_pStorage )
 612         throw uno::RuntimeException();
 613
 614     SvStorageInfoList aList;
 615     m_pStorage->FillInfoList( &aList );
 616
 617     if ( m_pStorage->GetError() )
 618     {
 619         m_pStorage->ResetError();
 620         throw uno::RuntimeException(); // TODO:
 621     }
 622
 623     return ( aList.size() != 0 );
 624 }
 625
 626 //____________________________________________________________________________________________________
 627 //  XComponent
 628 //____________________________________________________________________________________________________
 629
 630 // --------------------------------------------------------------------------------
 631 void SAL_CALL OLESimpleStorage::dispose()
 632         throw ( uno::RuntimeException )
 633 {
 634     ::osl::MutexGuard aGuard( m_aMutex );
 635
 636     if ( m_bDisposed )
 637         throw lang::DisposedException();
 638
 639     if ( m_pListenersContainer )
 640     {
 641            lang::EventObject aSource( static_cast< ::cppu::OWeakObject* >(this) );
 642         m_pListenersContainer->disposeAndClear( aSource );
 643     }
 644
 645     DELETEZ( m_pStorage );
 646     DELETEZ( m_pStream );
 647
 648     m_xStream = uno::Reference< io::XStream >();
 649     m_xTempStream = uno::Reference< io::XStream >();
 650
 651     m_bDisposed = sal_True;
 652 }
 653
 654 // --------------------------------------------------------------------------------
 655 void SAL_CALL OLESimpleStorage::addEventListener(
 656             const uno::Reference< lang::XEventListener >& xListener )
 657         throw ( uno::RuntimeException )
 658 {
 659     ::osl::MutexGuard aGuard( m_aMutex );
 660
 661     if ( m_bDisposed )
 662         throw lang::DisposedException();
 663
 664     if ( !m_pListenersContainer )
 665         m_pListenersContainer = new ::cppu::OInterfaceContainerHelper( m_aMutex );
 666
 667     m_pListenersContainer->addInterface( xListener );
 668 }
 669
 670 // --------------------------------------------------------------------------------
 671 void SAL_CALL OLESimpleStorage::removeEventListener(
 672             const uno::Reference< lang::XEventListener >& xListener )
 673         throw ( uno::RuntimeException )
 674 {
 675     ::osl::MutexGuard aGuard( m_aMutex );
 676
 677     if ( m_bDisposed )
 678         throw lang::DisposedException();
 679
 680     if ( m_pListenersContainer )
 681         m_pListenersContainer->removeInterface( xListener );
 682 }
 683
 684 //____________________________________________________________________________________________________
 685 //  XTransactedObject
 686 //____________________________________________________________________________________________________
 687
 688 // --------------------------------------------------------------------------------
 689 void SAL_CALL OLESimpleStorage::commit()
 690         throw ( ::com::sun::star::io::IOException,
 691                 ::com::sun::star::lang::WrappedTargetException,
 692                 ::com::sun::star::uno::RuntimeException )
 693 {
 694     ::osl::MutexGuard aGuard( m_aMutex );
 695
 696     if ( m_bDisposed )
 697         throw lang::DisposedException();
 698
 699      if ( !m_pStorage )
 700         throw uno::RuntimeException();
 701
 702     if ( !m_bNoTemporaryCopy && !m_xStream.is() )
 703         throw io::IOException(); // TODO
 704
 705     if ( !m_pStorage->Commit() || m_pStorage->GetError() )
 706     {
 707         m_pStorage->ResetError();
 708         throw io::IOException(); // TODO
 709     }
 710
 711     UpdateOriginal_Impl();
 712 }
 713
 714 // --------------------------------------------------------------------------------
 715 void SAL_CALL OLESimpleStorage::revert()
 716         throw ( ::com::sun::star::io::IOException,
 717                 ::com::sun::star::lang::WrappedTargetException,
 718                 ::com::sun::star::uno::RuntimeException )
 719 {
 720     ::osl::MutexGuard aGuard( m_aMutex );
 721
 722     if ( m_bDisposed )
 723         throw lang::DisposedException();
 724
 725      if ( !m_pStorage )
 726         throw uno::RuntimeException();
 727
 728     if ( !m_bNoTemporaryCopy && !m_xStream.is() )
 729         throw io::IOException(); // TODO
 730
 731     if ( !m_pStorage->Revert() || m_pStorage->GetError() )
 732     {
 733         m_pStorage->ResetError();
 734         throw io::IOException(); // TODO
 735     }
 736
 737     UpdateOriginal_Impl();
 738 }
 739
 740 //____________________________________________________________________________________________________
 741 //  XClassifiedObject
 742 //____________________________________________________________________________________________________
 743
 744 uno::Sequence< sal_Int8 > SAL_CALL OLESimpleStorage::getClassID()
 745     throw ( uno::RuntimeException )
 746 {
 747     ::osl::MutexGuard aGuard( m_aMutex );
 748
 749     if ( m_bDisposed )
 750         throw lang::DisposedException();
 751
 752     if ( !m_pStorage )
 753         throw uno::RuntimeException();
 754
 755     return m_pStorage->GetClassName().GetByteSequence();
 756 }
 757
 758 OUString SAL_CALL OLESimpleStorage::getClassName()
 759     throw ( uno::RuntimeException )
 760 {
 761     return OUString();
 762 }
 763
 764 void SAL_CALL OLESimpleStorage::setClassInfo( const uno::Sequence< sal_Int8 >& /*aClassID*/,
 765                             const OUString& /*sClassName*/ )
 766         throw ( lang::NoSupportException,
 767                 uno::RuntimeException )
 768 {
 769     throw lang::NoSupportException();
 770 }
 771
 772 //____________________________________________________________________________________________________
 773 //  XServiceInfo
 774 //____________________________________________________________________________________________________
 775
 776 // --------------------------------------------------------------------------------
 777 OUString SAL_CALL OLESimpleStorage::getImplementationName()
 778         throw ( uno::RuntimeException )
 779 {
 780     return impl_staticGetImplementationName();
 781 }
 782
 783 // --------------------------------------------------------------------------------
 784 ::sal_Bool SAL_CALL OLESimpleStorage::supportsService( const OUString& ServiceName )
 785         throw ( uno::RuntimeException )
 786 {
 787     uno::Sequence< OUString > aSeq = impl_staticGetSupportedServiceNames();
 788
 789     for ( sal_Int32 nInd = 0; nInd < aSeq.getLength(); nInd++ )
 790         if ( ServiceName == aSeq[nInd] )
 791             return sal_True;
 792
 793     return sal_False;
 794 }
 795
 796 // --------------------------------------------------------------------------------
 797 uno::Sequence< OUString > SAL_CALL OLESimpleStorage::getSupportedServiceNames()
 798         throw ( uno::RuntimeException )
 799 {
 800     return impl_staticGetSupportedServiceNames();
 801 }
 802
 803
 804 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */