svtools/source/fsstor/ostreamcontainer.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: ostreamcontainer.cxx,v $
  10  * $Revision: 1.4 $
  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_svtools.hxx"
  33
  34 #include "ostreamcontainer.hxx"
  35
  36
  37 using namespace ::com::sun::star;
  38
  39 //-----------------------------------------------
  40 OFSStreamContainer::OFSStreamContainer( const uno::Reference < io::XStream >& xStream )
  41 : m_bDisposed( sal_False )
  42 , m_bInputClosed( sal_False )
  43 , m_bOutputClosed( sal_False )
  44 , m_pListenersContainer( NULL )
  45 , m_pTypeCollection( NULL )
  46 {
  47     try
  48     {
  49         m_xStream = xStream;
  50         if ( !m_xStream.is() )
  51             throw uno::RuntimeException();
  52
  53         m_xSeekable = uno::Reference< io::XSeekable >( xStream, uno::UNO_QUERY );
  54         m_xInputStream = xStream->getInputStream();
  55         m_xOutputStream = xStream->getOutputStream();
  56         m_xTruncate = uno::Reference< io::XTruncate >( m_xOutputStream, uno::UNO_QUERY );
  57         m_xAsyncOutputMonitor = uno::Reference< io::XAsyncOutputMonitor >( m_xOutputStream, uno::UNO_QUERY );
  58     }
  59     catch( uno::Exception& )
  60     {
  61         m_xStream = uno::Reference< io::XStream >();
  62         m_xSeekable = uno::Reference< io::XSeekable >();
  63         m_xInputStream = uno::Reference< io::XInputStream >();
  64         m_xOutputStream = uno::Reference< io::XOutputStream >();
  65         m_xTruncate = uno::Reference< io::XTruncate >();
  66         m_xAsyncOutputMonitor = uno::Reference< io::XAsyncOutputMonitor >();
  67     }
  68 }
  69
  70 //-----------------------------------------------
  71 OFSStreamContainer::~OFSStreamContainer()
  72 {
  73     if ( m_pListenersContainer )
  74     {
  75         delete m_pListenersContainer;
  76         m_pListenersContainer = NULL;
  77     }
  78 }
  79
  80 // XInterface
  81 //-----------------------------------------------
  82 uno::Any SAL_CALL OFSStreamContainer::queryInterface( const uno::Type& rType )
  83         throw( uno::RuntimeException )
  84 {
  85     uno::Any aReturn;
  86
  87     aReturn <<= ::cppu::queryInterface
  88                 (       rType
  89                     ,   static_cast<lang::XTypeProvider*> ( this )
  90                     ,   static_cast<io::XStream*> ( this )
  91                     ,   static_cast<embed::XExtendedStorageStream*> ( this )
  92                     ,   static_cast<lang::XComponent*> ( this ) );
  93
  94     if ( aReturn.hasValue() == sal_True )
  95         return aReturn ;
  96
  97     if ( m_xSeekable.is() )
  98     {
  99         aReturn <<= ::cppu::queryInterface
 100                 (       rType
 101                     ,   static_cast<io::XSeekable*> ( this ) );
 102
 103         if ( aReturn.hasValue() == sal_True )
 104             return aReturn ;
 105     }
 106
 107     if ( m_xInputStream.is() )
 108     {
 109         aReturn <<= ::cppu::queryInterface
 110                 (       rType
 111                     ,   static_cast<io::XInputStream*> ( this ) );
 112
 113         if ( aReturn.hasValue() == sal_True )
 114             return aReturn ;
 115     }
 116     if ( m_xOutputStream.is() )
 117     {
 118         aReturn <<= ::cppu::queryInterface
 119                 (       rType
 120                     ,   static_cast<io::XOutputStream*> ( this ) );
 121
 122         if ( aReturn.hasValue() == sal_True )
 123             return aReturn ;
 124     }
 125     if ( m_xTruncate.is() )
 126     {
 127         aReturn <<= ::cppu::queryInterface
 128                 (       rType
 129                     ,   static_cast<io::XTruncate*> ( this ) );
 130
 131         if ( aReturn.hasValue() == sal_True )
 132             return aReturn ;
 133     }
 134     if ( m_xAsyncOutputMonitor.is() )
 135     {
 136         aReturn <<= ::cppu::queryInterface
 137                 (       rType
 138                     ,   static_cast<io::XAsyncOutputMonitor*> ( this ) );
 139
 140         if ( aReturn.hasValue() == sal_True )
 141             return aReturn ;
 142     }
 143
 144     return OWeakObject::queryInterface( rType );
 145 }
 146
 147 //-----------------------------------------------
 148 void SAL_CALL OFSStreamContainer::acquire()
 149         throw()
 150 {
 151     OWeakObject::acquire();
 152 }
 153
 154 //-----------------------------------------------
 155 void SAL_CALL OFSStreamContainer::release()
 156         throw()
 157 {
 158     OWeakObject::release();
 159 }
 160
 161 //      XTypeProvider
 162 //-----------------------------------------------
 163 uno::Sequence< uno::Type > SAL_CALL OFSStreamContainer::getTypes()
 164         throw( uno::RuntimeException )
 165 {
 166     if ( m_pTypeCollection == NULL )
 167     {
 168         ::osl::MutexGuard aGuard( m_aMutex );
 169
 170         if ( m_pTypeCollection == NULL )
 171         {
 172             ::cppu::OTypeCollection aTypeCollection
 173                                     (   ::getCppuType( ( const uno::Reference< lang::XTypeProvider >* )NULL )
 174                                     ,   ::getCppuType( ( const uno::Reference< embed::XExtendedStorageStream >* )NULL ) );
 175
 176             if ( m_xSeekable.is() )
 177                 aTypeCollection = ::cppu::OTypeCollection
 178                                     (   ::getCppuType( ( const uno::Reference< io::XSeekable >* )NULL ),
 179                                         aTypeCollection.getTypes() );
 180             if ( m_xInputStream.is() )
 181                 aTypeCollection = ::cppu::OTypeCollection
 182                                     (   ::getCppuType( ( const uno::Reference< io::XInputStream >* )NULL ),
 183                                         aTypeCollection.getTypes() );
 184
 185             if ( m_xOutputStream.is() )
 186                 aTypeCollection = ::cppu::OTypeCollection
 187                                     (   ::getCppuType( ( const uno::Reference< io::XOutputStream >* )NULL ),
 188                                         aTypeCollection.getTypes() );
 189             if ( m_xTruncate.is() )
 190                 aTypeCollection = ::cppu::OTypeCollection
 191                                     (   ::getCppuType( ( const uno::Reference< io::XTruncate >* )NULL ),
 192                                         aTypeCollection.getTypes() );
 193             if ( m_xAsyncOutputMonitor.is() )
 194                 aTypeCollection = ::cppu::OTypeCollection
 195                                     (   ::getCppuType( ( const uno::Reference< io::XAsyncOutputMonitor >* )NULL ),
 196                                         aTypeCollection.getTypes() );
 197
 198             m_pTypeCollection = new ::cppu::OTypeCollection( aTypeCollection );
 199         }
 200     }
 201     return m_pTypeCollection->getTypes() ;
 202 }
 203
 204 //-----------------------------------------------
 205 uno::Sequence< sal_Int8 > SAL_CALL OFSStreamContainer::getImplementationId()
 206         throw( uno::RuntimeException )
 207 {
 208     static ::cppu::OImplementationId* pID = NULL ;
 209
 210     if ( pID == NULL )
 211     {
 212         ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() ) ;
 213
 214         if ( pID == NULL )
 215         {
 216             static ::cppu::OImplementationId aID( sal_False ) ;
 217             pID = &aID ;
 218         }
 219     }
 220
 221     return pID->getImplementationId() ;
 222 }
 223
 224 // XStream
 225 //-----------------------------------------------
 226 uno::Reference< io::XInputStream > SAL_CALL OFSStreamContainer::getInputStream()
 227         throw ( uno::RuntimeException )
 228 {
 229     ::osl::MutexGuard aGuard( m_aMutex );
 230
 231     if ( m_bDisposed )
 232         throw lang::DisposedException();
 233
 234     if ( !m_xStream.is() )
 235         throw uno::RuntimeException();
 236
 237     if ( m_xInputStream.is() )
 238         return uno::Reference< io::XInputStream >( static_cast< io::XInputStream* >( this ) );
 239
 240     return uno::Reference< io::XInputStream >();
 241 }
 242
 243 //-----------------------------------------------
 244 uno::Reference< io::XOutputStream > SAL_CALL OFSStreamContainer::getOutputStream()
 245         throw ( uno::RuntimeException )
 246 {
 247     ::osl::MutexGuard aGuard( m_aMutex );
 248
 249     if ( m_bDisposed )
 250         throw lang::DisposedException();
 251
 252     if ( !m_xStream.is() )
 253         throw uno::RuntimeException();
 254
 255     if ( m_xOutputStream.is() )
 256         return uno::Reference< io::XOutputStream >( static_cast< io::XOutputStream* >( this ) );
 257
 258     return uno::Reference< io::XOutputStream >();
 259 }
 260
 261 // XComponent
 262 //-----------------------------------------------
 263 void SAL_CALL OFSStreamContainer::dispose()
 264         throw ( uno::RuntimeException )
 265 {
 266     ::osl::MutexGuard aGuard( m_aMutex );
 267
 268     if ( m_bDisposed )
 269         throw lang::DisposedException();
 270
 271     if ( !m_xStream.is() )
 272         throw uno::RuntimeException();
 273
 274     if ( m_xInputStream.is() && !m_bInputClosed )
 275     {
 276         m_xInputStream->closeInput();
 277         m_bInputClosed = sal_True;
 278     }
 279
 280     if ( m_xOutputStream.is() && !m_bOutputClosed )
 281     {
 282         m_xOutputStream->closeOutput();
 283         m_bOutputClosed = sal_True;
 284     }
 285
 286     if ( m_pListenersContainer )
 287     {
 288         lang::EventObject aSource( static_cast< ::cppu::OWeakObject*>( this ) );
 289         m_pListenersContainer->disposeAndClear( aSource );
 290     }
 291
 292     m_bDisposed = sal_True;
 293 }
 294
 295 //-----------------------------------------------
 296 void SAL_CALL OFSStreamContainer::addEventListener( const uno::Reference< lang::XEventListener >& xListener )
 297         throw ( uno::RuntimeException )
 298 {
 299     ::osl::MutexGuard aGuard( m_aMutex );
 300
 301     if ( m_bDisposed )
 302         throw lang::DisposedException();
 303
 304     if ( !m_pListenersContainer )
 305         m_pListenersContainer = new ::cppu::OInterfaceContainerHelper( m_aMutex );
 306
 307     m_pListenersContainer->addInterface( xListener );
 308 }
 309
 310 //-----------------------------------------------
 311 void SAL_CALL OFSStreamContainer::removeEventListener( const uno::Reference< lang::XEventListener >& xListener )
 312         throw ( uno::RuntimeException )
 313 {
 314     ::osl::MutexGuard aGuard( m_aMutex );
 315
 316     if ( m_bDisposed )
 317         throw lang::DisposedException();
 318
 319     if ( m_pListenersContainer )
 320         m_pListenersContainer->removeInterface( xListener );
 321 }
 322
 323
 324 // XSeekable
 325 //-----------------------------------------------
 326 void SAL_CALL OFSStreamContainer::seek( sal_Int64 location )
 327         throw ( lang::IllegalArgumentException,
 328                 io::IOException,
 329                 uno::RuntimeException )
 330 {
 331     ::osl::MutexGuard aGuard( m_aMutex );
 332
 333     if ( m_bDisposed )
 334         throw lang::DisposedException();
 335
 336     if ( !m_xStream.is() || !m_xSeekable.is() )
 337         throw uno::RuntimeException();
 338
 339     m_xSeekable->seek( location );
 340 }
 341
 342 //-----------------------------------------------
 343 sal_Int64 SAL_CALL OFSStreamContainer::getPosition()
 344         throw ( io::IOException,
 345                 uno::RuntimeException )
 346 {
 347     ::osl::MutexGuard aGuard( m_aMutex );
 348
 349     if ( m_bDisposed )
 350         throw lang::DisposedException();
 351
 352     if ( !m_xStream.is() || !m_xSeekable.is() )
 353         throw uno::RuntimeException();
 354
 355     return m_xSeekable->getPosition();
 356 }
 357
 358 //-----------------------------------------------
 359 sal_Int64 SAL_CALL OFSStreamContainer::getLength()
 360         throw ( io::IOException,
 361                 uno::RuntimeException )
 362 {
 363     ::osl::MutexGuard aGuard( m_aMutex );
 364
 365     if ( m_bDisposed )
 366         throw lang::DisposedException();
 367
 368     if ( !m_xStream.is() || !m_xSeekable.is() )
 369         throw uno::RuntimeException();
 370
 371     return m_xSeekable->getLength();
 372 }
 373
 374
 375 // XInputStream
 376 //-----------------------------------------------
 377 sal_Int32 SAL_CALL OFSStreamContainer::readBytes( uno::Sequence< sal_Int8 >& aData, sal_Int32 nBytesToRead )
 378         throw( io::NotConnectedException,
 379                 io::BufferSizeExceededException,
 380                 io::IOException,
 381                 uno::RuntimeException )
 382 {
 383     ::osl::MutexGuard aGuard( m_aMutex );
 384
 385     if ( m_bDisposed )
 386         throw lang::DisposedException();
 387
 388     if ( !m_xStream.is() || !m_xInputStream.is() )
 389         throw uno::RuntimeException();
 390
 391     return m_xInputStream->readBytes( aData, nBytesToRead );
 392 }
 393
 394 //-----------------------------------------------
 395 sal_Int32 SAL_CALL OFSStreamContainer::readSomeBytes( uno::Sequence< sal_Int8 >& aData, sal_Int32 nMaxBytesToRead )
 396         throw( io::NotConnectedException,
 397                 io::BufferSizeExceededException,
 398                 io::IOException,
 399                 uno::RuntimeException )
 400 {
 401     ::osl::MutexGuard aGuard( m_aMutex );
 402
 403     if ( m_bDisposed )
 404         throw lang::DisposedException();
 405
 406     if ( !m_xStream.is() || !m_xInputStream.is() )
 407         throw uno::RuntimeException();
 408
 409     return m_xInputStream->readSomeBytes( aData, nMaxBytesToRead );
 410 }
 411
 412 //-----------------------------------------------
 413 void SAL_CALL OFSStreamContainer::skipBytes( sal_Int32 nBytesToSkip )
 414         throw( io::NotConnectedException,
 415                 io::BufferSizeExceededException,
 416                 io::IOException,
 417                 uno::RuntimeException )
 418 {
 419     ::osl::MutexGuard aGuard( m_aMutex );
 420
 421     if ( m_bDisposed )
 422         throw lang::DisposedException();
 423
 424     if ( !m_xStream.is() || !m_xInputStream.is() )
 425         throw uno::RuntimeException();
 426
 427     m_xInputStream->skipBytes( nBytesToSkip );
 428 }
 429
 430 //-----------------------------------------------
 431 sal_Int32 SAL_CALL OFSStreamContainer::available()
 432         throw( io::NotConnectedException,
 433                 io::IOException,
 434                 uno::RuntimeException )
 435 {
 436     ::osl::MutexGuard aGuard( m_aMutex );
 437
 438     if ( m_bDisposed )
 439         throw lang::DisposedException();
 440
 441     if ( !m_xStream.is() || !m_xInputStream.is() )
 442         throw uno::RuntimeException();
 443
 444     return m_xInputStream->available();
 445 }
 446
 447 //-----------------------------------------------
 448 void SAL_CALL OFSStreamContainer::closeInput()
 449         throw( io::NotConnectedException,
 450                 io::IOException,
 451                 uno::RuntimeException )
 452 {
 453     ::osl::MutexGuard aGuard( m_aMutex );
 454
 455     if ( m_bDisposed )
 456         throw lang::DisposedException();
 457
 458     if ( !m_xStream.is() || !m_xInputStream.is() )
 459         throw uno::RuntimeException();
 460
 461     if ( m_xInputStream.is() )
 462     {
 463         m_xInputStream->closeInput();
 464         m_bInputClosed = sal_True;
 465     }
 466
 467     if ( m_bOutputClosed )
 468         dispose();
 469 }
 470
 471 // XOutputStream
 472 //-----------------------------------------------
 473 void SAL_CALL OFSStreamContainer::writeBytes( const uno::Sequence< sal_Int8 >& aData )
 474         throw ( io::NotConnectedException,
 475                 io::BufferSizeExceededException,
 476                 io::IOException,
 477                 uno::RuntimeException )
 478 {
 479     ::osl::MutexGuard aGuard( m_aMutex );
 480
 481     if ( m_bDisposed )
 482         throw lang::DisposedException();
 483
 484     if ( !m_xStream.is() || !m_xOutputStream.is() )
 485         throw uno::RuntimeException();
 486
 487     return m_xOutputStream->writeBytes( aData );
 488 }
 489
 490 //-----------------------------------------------
 491 void SAL_CALL OFSStreamContainer::flush()
 492         throw ( io::NotConnectedException,
 493                 io::BufferSizeExceededException,
 494                 io::IOException,
 495                 uno::RuntimeException )
 496 {
 497     ::osl::MutexGuard aGuard( m_aMutex );
 498
 499     if ( m_bDisposed )
 500         throw lang::DisposedException();
 501
 502     if ( !m_xStream.is() || !m_xOutputStream.is() )
 503         throw uno::RuntimeException();
 504
 505     return m_xOutputStream->flush();
 506 }
 507
 508 //-----------------------------------------------
 509 void SAL_CALL OFSStreamContainer::closeOutput()
 510         throw ( io::NotConnectedException,
 511                 io::BufferSizeExceededException,
 512                 io::IOException,
 513                 uno::RuntimeException )
 514 {
 515     ::osl::MutexGuard aGuard( m_aMutex );
 516
 517     if ( m_bDisposed )
 518         throw lang::DisposedException();
 519
 520     if ( !m_xStream.is() || !m_xOutputStream.is() )
 521         throw uno::RuntimeException();
 522
 523     if ( m_xOutputStream.is() )
 524     {
 525         m_xOutputStream->closeOutput();
 526         m_bOutputClosed = sal_True;
 527     }
 528
 529     if ( m_bInputClosed )
 530         dispose();
 531 }
 532
 533
 534 // XTruncate
 535 //-----------------------------------------------
 536 void SAL_CALL OFSStreamContainer::truncate()
 537         throw ( io::IOException,
 538                 uno::RuntimeException )
 539 {
 540     ::osl::MutexGuard aGuard( m_aMutex );
 541
 542     if ( m_bDisposed )
 543         throw lang::DisposedException();
 544
 545     if ( !m_xStream.is() || !m_xTruncate.is() )
 546         throw uno::RuntimeException();
 547
 548     m_xTruncate->truncate();
 549 }
 550
 551
 552 // XAsyncOutputMonitor
 553 //-----------------------------------------------
 554 void SAL_CALL OFSStreamContainer::waitForCompletion()
 555         throw ( io::IOException,
 556                 uno::RuntimeException )
 557 {
 558     ::osl::MutexGuard aGuard( m_aMutex );
 559
 560     if ( m_bDisposed )
 561         throw lang::DisposedException();
 562
 563     if ( !m_xStream.is() || !m_xAsyncOutputMonitor.is() )
 564         throw uno::RuntimeException();
 565
 566     m_xAsyncOutputMonitor->waitForCompletion();
 567 }
 568
 569
 570