ucb/source/ucp/tdoc/tdoc_stgelems.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
  21 /**************************************************************************
  22                                 TODO
  23  **************************************************************************
  24
  25  - remove root storage access workaround
  26
  27  *************************************************************************/
  28
  29 #include <osl/diagnose.h>
  30
  31 #include "com/sun/star/lang/DisposedException.hpp"
  32 #include "com/sun/star/reflection/ProxyFactory.hpp"
  33
  34 #include "tdoc_uri.hxx"
  35
  36 #include "tdoc_stgelems.hxx"
  37
  38 using namespace com::sun::star;
  39 using namespace tdoc_ucp;
  40
  41
  42
  43
  44 // ParentStorageHolder Implementation.
  45
  46
  47
  48
  49 ParentStorageHolder::ParentStorageHolder(
  50             const uno::Reference< embed::XStorage > & xParentStorage,
  51             const OUString & rUri )
  52 : m_xParentStorage( xParentStorage ),
  53   m_bParentIsRootStorage( false )
  54 {
  55     Uri aUri( rUri );
  56     if ( aUri.isDocument() )
  57         m_bParentIsRootStorage = true;
  58 }
  59
  60
  61
  62
  63 // Storage Implementation.
  64
  65
  66
  67
  68 Storage::Storage( const uno::Reference< uno::XComponentContext > & rxContext,
  69                   const rtl::Reference< StorageElementFactory > & xFactory,
  70                   const OUString & rUri,
  71                   const uno::Reference< embed::XStorage > & xParentStorage,
  72                   const uno::Reference< embed::XStorage > & xStorageToWrap )
  73 : ParentStorageHolder( xParentStorage, Uri( rUri ).getParentUri() ),
  74   m_xFactory( xFactory ),
  75   m_xWrappedStorage( xStorageToWrap ),
  76   m_xWrappedTransObj( xStorageToWrap, uno::UNO_QUERY ), // optional interface
  77   m_xWrappedComponent( xStorageToWrap, uno::UNO_QUERY ),
  78   m_xWrappedTypeProv( xStorageToWrap, uno::UNO_QUERY ),
  79   m_bIsDocumentStorage( Uri( rUri ).isDocument() )
  80 {
  81     OSL_ENSURE( m_xWrappedStorage.is(),
  82                 "Storage::Storage: No storage to wrap!" );
  83
  84     OSL_ENSURE( m_xWrappedComponent.is(),
  85                 "Storage::Storage: No component to wrap!" );
  86
  87     OSL_ENSURE( m_xWrappedTypeProv.is(),
  88                 "Storage::Storage: No Type Provider!" );
  89
  90     // Use proxy factory service to create aggregatable proxy.
  91     try
  92     {
  93         uno::Reference< reflection::XProxyFactory > xProxyFac =
  94             reflection::ProxyFactory::create( rxContext );
  95         m_xAggProxy = xProxyFac->createProxy( m_xWrappedStorage );
  96     }
  97     catch ( uno::Exception const & )
  98     {
  99         OSL_FAIL( "Storage::Storage: Caught exception!" );
 100     }
 101
 102     OSL_ENSURE( m_xAggProxy.is(),
 103                 "Storage::Storage: Wrapped storage cannot be aggregated!" );
 104
 105     if ( m_xAggProxy.is() )
 106     {
 107         osl_atomic_increment( &m_refCount );
 108         {
 109             // Solaris compiler problem:
 110             // Extra block to enforce destruction of temporary object created
 111             // in next statement _before_ osl_atomic_decrement is
 112             // called.  Otherwise 'this' will destroy itself even before ctor
 113             // is completed (See impl. of XInterface::release())!
 114
 115             m_xAggProxy->setDelegator(
 116                 static_cast< cppu::OWeakObject * >( this ) );
 117         }
 118         osl_atomic_decrement( &m_refCount );
 119     }
 120 }
 121
 122
 123 // virtual
 124 Storage::~Storage()
 125 {
 126     if ( m_xAggProxy.is() )
 127         m_xAggProxy->setDelegator( uno::Reference< uno::XInterface >() );
 128
 129     // Never dispose a document storage. Not owner!
 130     if ( !isDocumentStorage() )
 131     {
 132         if ( m_xWrappedComponent.is() )
 133         {
 134             // "Auto-dispose"...
 135             try
 136             {
 137                 m_xWrappedComponent->dispose();
 138             }
 139             catch ( lang::DisposedException const & )
 140             {
 141                 // might happen.
 142             }
 143             catch ( ... )
 144             {
 145                 OSL_FAIL( "Storage::~Storage - Caught exception!" );
 146             }
 147         }
 148     }
 149 }
 150
 151
 152
 153 // uno::XInterface
 154
 155
 156
 157 // virtual
 158 uno::Any SAL_CALL Storage::queryInterface( const uno::Type& aType )
 159     throw ( uno::RuntimeException, std::exception )
 160 {
 161     // First, try to use interfaces implemented by myself and base class(es)
 162     uno::Any aRet = StorageUNOBase::queryInterface( aType );
 163
 164     if ( aRet.hasValue() )
 165         return aRet;
 166
 167     // Try to use requested interface from aggregated storage
 168     return m_xAggProxy->queryAggregation( aType );
 169 }
 170
 171
 172 // virtual
 173 void SAL_CALL Storage::acquire()
 174     throw ()
 175 {
 176     osl_atomic_increment( &m_refCount );
 177 }
 178
 179
 180 // virtual
 181 void SAL_CALL Storage::release()
 182     throw ()
 183 {
 184     //#i120738, Storage::release overrides OWeakObject::release(),
 185     //need call OWeakObject::release() to release OWeakObject::m_pWeakConnectionPoint
 186
 187     if ( m_refCount == 1 )
 188         m_xFactory->releaseElement( this );
 189
 190     //delete this;
 191     OWeakObject::release();
 192 }
 193
 194
 195
 196 // lang::XTypeProvider
 197
 198
 199
 200 // virtual
 201 uno::Sequence< uno::Type > SAL_CALL Storage::getTypes()
 202     throw ( uno::RuntimeException, std::exception )
 203 {
 204     return m_xWrappedTypeProv->getTypes();
 205 }
 206
 207
 208 // virtual
 209 uno::Sequence< sal_Int8 > SAL_CALL Storage::getImplementationId()
 210     throw ( uno::RuntimeException, std::exception )
 211 {
 212     return css::uno::Sequence<sal_Int8>();
 213 }
 214
 215
 216
 217 // lang::XComponent (base of embed::XStorage)
 218
 219
 220 // virtual
 221 void SAL_CALL Storage::dispose()
 222     throw ( uno::RuntimeException, std::exception )
 223 {
 224     m_xWrappedStorage->dispose();
 225 }
 226
 227
 228 // virtual
 229 void SAL_CALL Storage::addEventListener(
 230         const uno::Reference< lang::XEventListener >& xListener )
 231     throw ( uno::RuntimeException, std::exception )
 232 {
 233     m_xWrappedStorage->addEventListener( xListener );
 234 }
 235
 236 // virtual
 237 void SAL_CALL Storage::removeEventListener(
 238         const uno::Reference< lang::XEventListener >& aListener )
 239     throw (uno::RuntimeException, std::exception)
 240 {
 241     m_xWrappedStorage->removeEventListener( aListener );
 242 }
 243
 244
 245
 246 // container::XElementAccess (base of container::XNameAccess)
 247
 248
 249
 250 // virtual
 251 uno::Type SAL_CALL Storage::getElementType()
 252     throw ( uno::RuntimeException, std::exception )
 253 {
 254     return m_xWrappedStorage->getElementType();
 255 }
 256
 257
 258 // virtual
 259 sal_Bool SAL_CALL Storage::hasElements()
 260     throw ( uno::RuntimeException, std::exception )
 261 {
 262     return m_xWrappedStorage->hasElements();
 263 }
 264
 265
 266
 267 // container::XNameAccess (base of embed::XStorage)
 268
 269
 270
 271 // virtual
 272 uno::Any SAL_CALL Storage::getByName( const OUString& aName )
 273     throw ( container::NoSuchElementException,
 274             lang::WrappedTargetException,
 275             uno::RuntimeException, std::exception )
 276 {
 277     return m_xWrappedStorage->getByName( aName );
 278 }
 279
 280
 281 // virtual
 282 uno::Sequence< OUString > SAL_CALL Storage::getElementNames()
 283     throw ( uno::RuntimeException, std::exception )
 284 {
 285     return m_xWrappedStorage->getElementNames();
 286 }
 287
 288
 289 // virtual
 290 sal_Bool SAL_CALL Storage::hasByName( const OUString& aName )
 291     throw ( uno::RuntimeException, std::exception )
 292 {
 293     return m_xWrappedStorage->hasByName( aName );
 294 }
 295
 296
 297
 298 // embed::XStorage
 299
 300
 301
 302 // virtual
 303 void SAL_CALL Storage::copyToStorage(
 304         const uno::Reference< embed::XStorage >& xDest )
 305     throw ( embed::InvalidStorageException,
 306             lang::IllegalArgumentException,
 307             io::IOException,
 308             embed::StorageWrappedTargetException,
 309             uno::RuntimeException, std::exception )
 310 {
 311     m_xWrappedStorage->copyToStorage( xDest );
 312 }
 313
 314
 315 // virtual
 316 uno::Reference< io::XStream > SAL_CALL Storage::openStreamElement(
 317         const OUString& aStreamName, sal_Int32 nOpenMode )
 318     throw ( embed::InvalidStorageException,
 319             lang::IllegalArgumentException,
 320             packages::WrongPasswordException,
 321             io::IOException,
 322             embed::StorageWrappedTargetException,
 323             uno::RuntimeException, std::exception )
 324 {
 325     return m_xWrappedStorage->openStreamElement( aStreamName, nOpenMode );
 326 }
 327
 328
 329 // virtual
 330 uno::Reference< io::XStream > SAL_CALL Storage::openEncryptedStreamElement(
 331         const OUString& aStreamName,
 332         sal_Int32 nOpenMode,
 333         const OUString& aPassword )
 334     throw ( embed::InvalidStorageException,
 335             lang::IllegalArgumentException,
 336             packages::NoEncryptionException,
 337             packages::WrongPasswordException,
 338             io::IOException,
 339             embed::StorageWrappedTargetException,
 340             uno::RuntimeException, std::exception )
 341 {
 342     return m_xWrappedStorage->openEncryptedStreamElement(
 343         aStreamName, nOpenMode, aPassword );
 344 }
 345
 346
 347 // virtual
 348 uno::Reference< embed::XStorage > SAL_CALL Storage::openStorageElement(
 349         const OUString& aStorName, sal_Int32 nOpenMode )
 350     throw ( embed::InvalidStorageException,
 351             lang::IllegalArgumentException,
 352             io::IOException,
 353             embed::StorageWrappedTargetException,
 354             uno::RuntimeException, std::exception )
 355 {
 356     return m_xWrappedStorage->openStorageElement( aStorName, nOpenMode );
 357 }
 358
 359
 360 // virtual
 361 uno::Reference< io::XStream > SAL_CALL Storage::cloneStreamElement(
 362         const OUString& aStreamName )
 363     throw ( embed::InvalidStorageException,
 364             lang::IllegalArgumentException,
 365             packages::WrongPasswordException,
 366             io::IOException,
 367             embed::StorageWrappedTargetException,
 368             uno::RuntimeException, std::exception )
 369 {
 370     return m_xWrappedStorage->cloneStreamElement( aStreamName );
 371 }
 372
 373
 374 // virtual
 375 uno::Reference< io::XStream > SAL_CALL Storage::cloneEncryptedStreamElement(
 376         const OUString& aStreamName,
 377         const OUString& aPassword )
 378     throw ( embed::InvalidStorageException,
 379             lang::IllegalArgumentException,
 380             packages::NoEncryptionException,
 381             packages::WrongPasswordException,
 382             io::IOException,
 383             embed::StorageWrappedTargetException,
 384             uno::RuntimeException, std::exception )
 385 {
 386     return m_xWrappedStorage->cloneEncryptedStreamElement( aStreamName,
 387                                                            aPassword );
 388 }
 389
 390
 391 // virtual
 392 void SAL_CALL Storage::copyLastCommitTo(
 393         const uno::Reference< embed::XStorage >& xTargetStorage )
 394     throw ( embed::InvalidStorageException,
 395             lang::IllegalArgumentException,
 396             io::IOException,
 397             embed::StorageWrappedTargetException,
 398             uno::RuntimeException, std::exception)
 399 {
 400     m_xWrappedStorage->copyLastCommitTo( xTargetStorage );
 401 }
 402
 403
 404 // virtual
 405 void SAL_CALL Storage::copyStorageElementLastCommitTo(
 406         const OUString& aStorName,
 407         const uno::Reference< embed::XStorage >& xTargetStorage )
 408     throw ( embed::InvalidStorageException,
 409             lang::IllegalArgumentException,
 410             io::IOException,
 411             embed::StorageWrappedTargetException,
 412             uno::RuntimeException, std::exception)
 413 {
 414     m_xWrappedStorage->copyStorageElementLastCommitTo( aStorName, xTargetStorage );
 415 }
 416
 417
 418 // virtual
 419 sal_Bool SAL_CALL Storage::isStreamElement(
 420         const OUString& aElementName )
 421     throw ( container::NoSuchElementException,
 422             lang::IllegalArgumentException,
 423             embed::InvalidStorageException,
 424             uno::RuntimeException, std::exception )
 425 {
 426     return m_xWrappedStorage->isStreamElement( aElementName );
 427 }
 428
 429
 430 // virtual
 431 sal_Bool SAL_CALL Storage::isStorageElement(
 432         const OUString& aElementName )
 433     throw ( container::NoSuchElementException,
 434             lang::IllegalArgumentException,
 435             embed::InvalidStorageException,
 436             uno::RuntimeException, std::exception )
 437 {
 438     return m_xWrappedStorage->isStorageElement( aElementName );
 439 }
 440
 441
 442 // virtual
 443 void SAL_CALL Storage::removeElement( const OUString& aElementName )
 444     throw ( embed::InvalidStorageException,
 445             lang::IllegalArgumentException,
 446             container::NoSuchElementException,
 447             io::IOException,
 448             embed::StorageWrappedTargetException,
 449             uno::RuntimeException, std::exception )
 450 {
 451     m_xWrappedStorage->removeElement( aElementName );
 452 }
 453
 454
 455 // virtual
 456 void SAL_CALL Storage::renameElement( const OUString& aEleName,
 457                                       const OUString& aNewName )
 458     throw ( embed::InvalidStorageException,
 459             lang::IllegalArgumentException,
 460             container::NoSuchElementException,
 461             container::ElementExistException,
 462             io::IOException,
 463             embed::StorageWrappedTargetException,
 464             uno::RuntimeException, std::exception )
 465 {
 466     m_xWrappedStorage->renameElement( aEleName, aNewName );
 467 }
 468
 469
 470 // virtual
 471 void SAL_CALL Storage::copyElementTo(
 472         const OUString& aElementName,
 473         const uno::Reference< embed::XStorage >& xDest,
 474         const OUString& aNewName )
 475     throw ( embed::InvalidStorageException,
 476             lang::IllegalArgumentException,
 477             container::NoSuchElementException,
 478             container::ElementExistException,
 479             io::IOException,
 480             embed::StorageWrappedTargetException,
 481             uno::RuntimeException, std::exception )
 482 {
 483     m_xWrappedStorage->copyElementTo( aElementName, xDest, aNewName );
 484 }
 485
 486
 487 // virtual
 488 void SAL_CALL Storage::moveElementTo(
 489         const OUString& aElementName,
 490         const uno::Reference< embed::XStorage >& xDest,
 491         const OUString& rNewName )
 492     throw ( embed::InvalidStorageException,
 493             lang::IllegalArgumentException,
 494             container::NoSuchElementException,
 495             container::ElementExistException,
 496             io::IOException,
 497             embed::StorageWrappedTargetException,
 498             uno::RuntimeException, std::exception )
 499 {
 500     m_xWrappedStorage->moveElementTo( aElementName, xDest, rNewName );
 501 }
 502
 503
 504
 505 // embed::XTransactedObject
 506
 507
 508
 509 // virtual
 510 void SAL_CALL Storage::commit()
 511     throw ( io::IOException,
 512             lang::WrappedTargetException,
 513             uno::RuntimeException, std::exception )
 514 {
 515     // Never commit a root storage (-> has no parent)!
 516     // Would lead in writing the whole document to disk.
 517
 518     uno::Reference< embed::XStorage > xParentStorage = getParentStorage();
 519     if ( xParentStorage.is() )
 520     {
 521         OSL_ENSURE( m_xWrappedTransObj.is(), "No XTransactedObject interface!" );
 522
 523         if ( m_xWrappedTransObj.is() )
 524         {
 525             m_xWrappedTransObj->commit();
 526
 527             if ( !isParentARootStorage() )
 528             {
 529                 uno::Reference< embed::XTransactedObject > xParentTA(
 530                     xParentStorage, uno::UNO_QUERY );
 531                 OSL_ENSURE( xParentTA.is(), "No XTransactedObject interface!" );
 532
 533                 if ( xParentTA.is() )
 534                     xParentTA->commit();
 535             }
 536         }
 537     }
 538 }
 539
 540
 541 // virtual
 542 void SAL_CALL Storage::revert()
 543     throw ( io::IOException,
 544             lang::WrappedTargetException,
 545             uno::RuntimeException, std::exception )
 546 {
 547     uno::Reference< embed::XStorage > xParentStorage = getParentStorage();
 548     if ( xParentStorage.is() )
 549     {
 550         OSL_ENSURE( m_xWrappedTransObj.is(), "No XTransactedObject interface!" );
 551
 552         if ( m_xWrappedTransObj.is() )
 553         {
 554             m_xWrappedTransObj->revert();
 555
 556             if ( !isParentARootStorage() )
 557             {
 558                 uno::Reference< embed::XTransactedObject > xParentTA(
 559                     xParentStorage, uno::UNO_QUERY );
 560                 OSL_ENSURE( xParentTA.is(), "No XTransactedObject interface!" );
 561
 562                 if ( xParentTA.is() )
 563                     xParentTA->revert();
 564             }
 565         }
 566     }
 567 }
 568
 569
 570
 571
 572 // OutputStream Implementation.
 573
 574
 575
 576
 577 OutputStream::OutputStream(
 578             const uno::Reference< uno::XComponentContext > & rxContext,
 579             const OUString & rUri,
 580             const uno::Reference< embed::XStorage >  & xParentStorage,
 581             const uno::Reference< io::XOutputStream > & xStreamToWrap )
 582 : ParentStorageHolder( xParentStorage, Uri( rUri ).getParentUri() ),
 583   m_xWrappedStream( xStreamToWrap ),
 584   m_xWrappedComponent( xStreamToWrap, uno::UNO_QUERY ),
 585   m_xWrappedTypeProv( xStreamToWrap, uno::UNO_QUERY )
 586 {
 587     OSL_ENSURE( m_xWrappedStream.is(),
 588                 "OutputStream::OutputStream: No stream to wrap!" );
 589
 590     OSL_ENSURE( m_xWrappedComponent.is(),
 591                 "OutputStream::OutputStream: No component to wrap!" );
 592
 593     OSL_ENSURE( m_xWrappedTypeProv.is(),
 594                 "OutputStream::OutputStream: No Type Provider!" );
 595
 596     // Use proxy factory service to create aggregatable proxy.
 597     try
 598     {
 599         uno::Reference< reflection::XProxyFactory > xProxyFac =
 600             reflection::ProxyFactory::create( rxContext );
 601         m_xAggProxy = xProxyFac->createProxy( m_xWrappedStream );
 602     }
 603     catch ( uno::Exception const & )
 604     {
 605         OSL_FAIL( "OutputStream::OutputStream: Caught exception!" );
 606     }
 607
 608     OSL_ENSURE( m_xAggProxy.is(),
 609             "OutputStream::OutputStream: Wrapped stream cannot be aggregated!" );
 610
 611     if ( m_xAggProxy.is() )
 612     {
 613         osl_atomic_increment( &m_refCount );
 614         {
 615             // Solaris compiler problem:
 616             // Extra block to enforce destruction of temporary object created
 617             // in next statement _before_ osl_atomic_decrement is
 618             // called.  Otherwise 'this' will destroy itself even before ctor
 619             // is completed (See impl. of XInterface::release())!
 620
 621             m_xAggProxy->setDelegator(
 622                 static_cast< cppu::OWeakObject * >( this ) );
 623         }
 624         osl_atomic_decrement( &m_refCount );
 625     }
 626 }
 627
 628
 629 // virtual
 630 OutputStream::~OutputStream()
 631 {
 632     if ( m_xAggProxy.is() )
 633         m_xAggProxy->setDelegator( uno::Reference< uno::XInterface >() );
 634 }
 635
 636
 637
 638 // uno::XInterface
 639
 640
 641
 642 // virtual
 643 uno::Any SAL_CALL OutputStream::queryInterface( const uno::Type& aType )
 644     throw ( uno::RuntimeException, std::exception )
 645 {
 646     uno::Any aRet = OutputStreamUNOBase::queryInterface( aType );
 647
 648     if ( aRet.hasValue() )
 649         return aRet;
 650
 651     if ( m_xAggProxy.is() )
 652         return m_xAggProxy->queryAggregation( aType );
 653     else
 654         return uno::Any();
 655 }
 656
 657
 658
 659 // lang::XTypeProvider
 660
 661
 662
 663 // virtual
 664 uno::Sequence< uno::Type > SAL_CALL OutputStream::getTypes()
 665     throw ( uno::RuntimeException, std::exception )
 666 {
 667     return m_xWrappedTypeProv->getTypes();
 668 }
 669
 670
 671 // virtual
 672 uno::Sequence< sal_Int8 > SAL_CALL OutputStream::getImplementationId()
 673     throw ( uno::RuntimeException, std::exception )
 674 {
 675     return css::uno::Sequence<sal_Int8>();
 676 }
 677
 678
 679
 680 // io::XOutputStream
 681
 682
 683
 684 // virtual
 685 void SAL_CALL
 686 OutputStream::writeBytes( const uno::Sequence< sal_Int8 >& aData )
 687     throw ( io::NotConnectedException,
 688             io::BufferSizeExceededException,
 689             io::IOException,
 690             uno::RuntimeException, std::exception )
 691 {
 692     m_xWrappedStream->writeBytes( aData );
 693 }
 694
 695
 696 // virtual
 697 void SAL_CALL
 698 OutputStream::flush()
 699     throw ( io::NotConnectedException,
 700             io::BufferSizeExceededException,
 701             io::IOException,
 702             uno::RuntimeException, std::exception )
 703 {
 704     m_xWrappedStream->flush();
 705 }
 706
 707
 708 // virtual
 709 void SAL_CALL
 710 OutputStream::closeOutput(  )
 711     throw ( io::NotConnectedException,
 712             io::BufferSizeExceededException,
 713             io::IOException,
 714             uno::RuntimeException, std::exception )
 715 {
 716     m_xWrappedStream->closeOutput();
 717
 718     // Release parent storage.
 719     // Now, that the stream is closed/disposed it is not needed any longer.
 720     setParentStorage( uno::Reference< embed::XStorage >() );
 721 }
 722
 723
 724
 725 // lang::XComponent
 726
 727
 728
 729 // virtual
 730 void SAL_CALL
 731 OutputStream::dispose()
 732     throw ( uno::RuntimeException, std::exception )
 733 {
 734     m_xWrappedComponent->dispose();
 735
 736     // Release parent storage.
 737     // Now, that the stream is closed/disposed it is not needed any longer.
 738     setParentStorage( uno::Reference< embed::XStorage >() );
 739 }
 740
 741
 742 // virtual
 743 void SAL_CALL
 744 OutputStream::addEventListener(
 745         const uno::Reference< lang::XEventListener >& xListener )
 746     throw ( uno::RuntimeException, std::exception )
 747 {
 748     m_xWrappedComponent->addEventListener( xListener );
 749 }
 750
 751
 752 // virtual
 753 void SAL_CALL
 754 OutputStream::removeEventListener(
 755         const uno::Reference< lang::XEventListener >& aListener )
 756     throw ( uno::RuntimeException, std::exception )
 757 {
 758     m_xWrappedComponent->removeEventListener( aListener );
 759 }
 760
 761
 762
 763
 764 // Stream Implementation.
 765
 766
 767
 768
 769 Stream::Stream(
 770             const uno::Reference< uno::XComponentContext > & rxContext,
 771             const OUString & rUri,
 772             const uno::Reference< embed::XStorage >  & xParentStorage,
 773             const uno::Reference< io::XStream > & xStreamToWrap )
 774 : ParentStorageHolder( xParentStorage, Uri( rUri ).getParentUri() ),
 775   m_xWrappedStream( xStreamToWrap ),
 776   m_xWrappedOutputStream( xStreamToWrap->getOutputStream() ), // might be empty
 777   m_xWrappedTruncate( m_xWrappedOutputStream, uno::UNO_QUERY ), // might be empty
 778   m_xWrappedInputStream( xStreamToWrap->getInputStream(), uno::UNO_QUERY ),
 779   m_xWrappedComponent( xStreamToWrap, uno::UNO_QUERY ),
 780   m_xWrappedTypeProv( xStreamToWrap, uno::UNO_QUERY )
 781 {
 782     OSL_ENSURE( m_xWrappedStream.is(),
 783                 "OutputStream::OutputStream: No stream to wrap!" );
 784
 785     OSL_ENSURE( m_xWrappedComponent.is(),
 786                 "OutputStream::OutputStream: No component to wrap!" );
 787
 788     OSL_ENSURE( m_xWrappedTypeProv.is(),
 789                 "OutputStream::OutputStream: No Type Provider!" );
 790
 791     // Use proxy factory service to create aggregatable proxy.
 792     try
 793     {
 794         uno::Reference< reflection::XProxyFactory > xProxyFac =
 795             reflection::ProxyFactory::create( rxContext );
 796         m_xAggProxy = xProxyFac->createProxy( m_xWrappedStream );
 797     }
 798     catch ( uno::Exception const & )
 799     {
 800         OSL_FAIL( "OutputStream::OutputStream: Caught exception!" );
 801     }
 802
 803     OSL_ENSURE( m_xAggProxy.is(),
 804             "OutputStream::OutputStream: Wrapped stream cannot be aggregated!" );
 805
 806     if ( m_xAggProxy.is() )
 807     {
 808         osl_atomic_increment( &m_refCount );
 809         {
 810             // Solaris compiler problem:
 811             // Extra block to enforce destruction of temporary object created
 812             // in next statement _before_ osl_atomic_decrement is
 813             // called.  Otherwise 'this' will destroy itself even before ctor
 814             // is completed (See impl. of XInterface::release())!
 815
 816             m_xAggProxy->setDelegator(
 817                 static_cast< cppu::OWeakObject * >( this ) );
 818         }
 819         osl_atomic_decrement( &m_refCount );
 820     }
 821 }
 822
 823
 824 // virtual
 825 Stream::~Stream()
 826 {
 827     if ( m_xAggProxy.is() )
 828         m_xAggProxy->setDelegator( uno::Reference< uno::XInterface >() );
 829 }
 830
 831
 832
 833 // uno::XInterface
 834
 835
 836
 837 // virtual
 838 uno::Any SAL_CALL Stream::queryInterface( const uno::Type& aType )
 839     throw ( uno::RuntimeException, std::exception )
 840 {
 841     uno::Any aRet = StreamUNOBase::queryInterface( aType );
 842
 843     if ( aRet.hasValue() )
 844         return aRet;
 845
 846     if ( m_xAggProxy.is() )
 847         return m_xAggProxy->queryAggregation( aType );
 848     else
 849         return uno::Any();
 850 }
 851
 852
 853
 854 // lang::XTypeProvider
 855
 856
 857
 858 // virtual
 859 uno::Sequence< uno::Type > SAL_CALL Stream::getTypes()
 860     throw ( uno::RuntimeException, std::exception )
 861 {
 862     return m_xWrappedTypeProv->getTypes();
 863 }
 864
 865
 866 // virtual
 867 uno::Sequence< sal_Int8 > SAL_CALL Stream::getImplementationId()
 868     throw ( uno::RuntimeException, std::exception )
 869 {
 870     return css::uno::Sequence<sal_Int8>();
 871 }
 872
 873
 874
 875 // io::XStream.
 876
 877
 878
 879 // virtual
 880 uno::Reference< io::XInputStream > SAL_CALL Stream::getInputStream()
 881     throw( uno::RuntimeException, std::exception )
 882 {
 883     return uno::Reference< io::XInputStream >( this );
 884 }
 885
 886
 887 // virtual
 888 uno::Reference< io::XOutputStream > SAL_CALL Stream::getOutputStream()
 889     throw( uno::RuntimeException, std::exception )
 890 {
 891     return uno::Reference< io::XOutputStream >( this );
 892 }
 893
 894
 895
 896 // io::XOutputStream.
 897
 898
 899
 900 // virtual
 901 void SAL_CALL Stream::writeBytes( const uno::Sequence< sal_Int8 >& aData )
 902     throw( io::NotConnectedException,
 903            io::BufferSizeExceededException,
 904            io::IOException,
 905            uno::RuntimeException, std::exception )
 906 {
 907     if ( m_xWrappedOutputStream.is() )
 908     {
 909         m_xWrappedOutputStream->writeBytes( aData );
 910         commitChanges();
 911     }
 912 }
 913
 914
 915 // virtual
 916 void SAL_CALL Stream::flush()
 917     throw( io::NotConnectedException,
 918            io::BufferSizeExceededException,
 919            io::IOException,
 920            uno::RuntimeException, std::exception )
 921 {
 922     if ( m_xWrappedOutputStream.is() )
 923     {
 924         m_xWrappedOutputStream->flush();
 925         commitChanges();
 926     }
 927 }
 928
 929
 930 // virtual
 931 void SAL_CALL Stream::closeOutput()
 932     throw( io::NotConnectedException,
 933            io::IOException,
 934            uno::RuntimeException, std::exception )
 935 {
 936     if ( m_xWrappedOutputStream.is() )
 937     {
 938         m_xWrappedOutputStream->closeOutput();
 939         commitChanges();
 940     }
 941
 942     // Release parent storage.
 943     // Now, that the stream is closed/disposed it is not needed any longer.
 944     setParentStorage( uno::Reference< embed::XStorage >() );
 945 }
 946
 947
 948
 949 // io::XTruncate.
 950
 951
 952
 953 // virtual
 954 void SAL_CALL Stream::truncate()
 955     throw( io::IOException,
 956            uno::RuntimeException, std::exception )
 957 {
 958     if ( m_xWrappedTruncate.is() )
 959     {
 960         m_xWrappedTruncate->truncate();
 961         commitChanges();
 962     }
 963 }
 964
 965
 966
 967 // io::XInputStream.
 968
 969
 970
 971 // virtual
 972 sal_Int32 SAL_CALL Stream::readBytes( uno::Sequence< sal_Int8 >& aData,
 973                                       sal_Int32 nBytesToRead )
 974     throw( io::NotConnectedException,
 975            io::BufferSizeExceededException,
 976            io::IOException,
 977            uno::RuntimeException, std::exception )
 978 {
 979     return m_xWrappedInputStream->readBytes( aData, nBytesToRead );
 980 }
 981
 982
 983 // virtual
 984 sal_Int32 SAL_CALL Stream::readSomeBytes( uno::Sequence< sal_Int8 >& aData,
 985                                           sal_Int32 nMaxBytesToRead )
 986     throw( io::NotConnectedException,
 987            io::BufferSizeExceededException,
 988            io::IOException,
 989            uno::RuntimeException, std::exception )
 990 {
 991     return m_xWrappedInputStream->readSomeBytes( aData, nMaxBytesToRead );
 992 }
 993
 994
 995 // virtual
 996 void SAL_CALL Stream::skipBytes( sal_Int32 nBytesToSkip )
 997     throw( io::NotConnectedException,
 998            io::BufferSizeExceededException,
 999            io::IOException,
1000            uno::RuntimeException, std::exception )
1001 {
1002     m_xWrappedInputStream->skipBytes( nBytesToSkip );
1003 }
1004
1005
1006 // virtual
1007 sal_Int32 SAL_CALL Stream::available()
1008     throw( io::NotConnectedException,
1009            io::IOException,
1010            uno::RuntimeException, std::exception )
1011 {
1012     return m_xWrappedInputStream->available();
1013 }
1014
1015
1016 // virtual
1017 void SAL_CALL Stream::closeInput()
1018     throw( io::NotConnectedException,
1019            io::IOException,
1020            uno::RuntimeException, std::exception )
1021 {
1022     m_xWrappedInputStream->closeInput();
1023 }
1024
1025
1026
1027 // lang::XComponent
1028
1029
1030
1031 // virtual
1032 void SAL_CALL Stream::dispose()
1033     throw ( uno::RuntimeException, std::exception )
1034 {
1035     m_xWrappedComponent->dispose();
1036
1037     // Release parent storage.
1038     // Now, that the stream is closed/disposed it is not needed any longer.
1039     setParentStorage( uno::Reference< embed::XStorage >() );
1040 }
1041
1042
1043 // virtual
1044 void SAL_CALL Stream::addEventListener(
1045         const uno::Reference< lang::XEventListener >& xListener )
1046     throw ( uno::RuntimeException, std::exception )
1047 {
1048     m_xWrappedComponent->addEventListener( xListener );
1049 }
1050
1051
1052 // virtual
1053 void SAL_CALL Stream::removeEventListener(
1054         const uno::Reference< lang::XEventListener >& aListener )
1055     throw ( uno::RuntimeException, std::exception )
1056 {
1057     m_xWrappedComponent->removeEventListener( aListener );
1058 }
1059
1060
1061
1062 // Non-UNO
1063
1064
1065
1066 void Stream::commitChanges()
1067     throw( io::IOException )
1068 {
1069     uno::Reference< embed::XTransactedObject >
1070         xParentTA( getParentStorage(), uno::UNO_QUERY );
1071     OSL_ENSURE( xParentTA.is(), "No XTransactedObject interface!" );
1072
1073     if ( xParentTA.is() )
1074     {
1075         try
1076         {
1077             xParentTA->commit();
1078         }
1079         catch ( lang::WrappedTargetException const & )
1080         {
1081             throw io::IOException(); // @@@
1082         }
1083     }
1084 }
1085
1086 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */