sot/source/unoolestorage/xolesimplestorage.cxx

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