svl/source/fsstor/ostreamcontainer.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 "ostreamcontainer.hxx"
  21
  22 #include <cppuhelper/queryinterface.hxx>
  23 #include <comphelper/sequence.hxx>
  24
  25
  26 using namespace ::com::sun::star;
  27
  28 OFSStreamContainer::OFSStreamContainer( const uno::Reference < io::XStream >& xStream )
  29 : m_bDisposed( false )
  30 , m_bInputClosed( false )
  31 , m_bOutputClosed( false )
  32 {
  33     try
  34     {
  35         m_xStream = xStream;
  36         if ( !m_xStream.is() )
  37             throw uno::RuntimeException();
  38
  39         m_xSeekable.set( xStream, uno::UNO_QUERY );
  40         m_xInputStream = xStream->getInputStream();
  41         m_xOutputStream = xStream->getOutputStream();
  42         m_xTruncate.set( m_xOutputStream, uno::UNO_QUERY );
  43         m_xAsyncOutputMonitor.set( m_xOutputStream, uno::UNO_QUERY );
  44     }
  45     catch( uno::Exception& )
  46     {
  47         m_xStream.clear();
  48         m_xSeekable.clear();
  49         m_xInputStream.clear();
  50         m_xOutputStream.clear();
  51         m_xTruncate.clear();
  52         m_xAsyncOutputMonitor.clear();
  53     }
  54 }
  55
  56 OFSStreamContainer::~OFSStreamContainer()
  57 {
  58 }
  59
  60 // XInterface
  61 uno::Any SAL_CALL OFSStreamContainer::queryInterface( const uno::Type& rType )
  62 {
  63     uno::Any aReturn = ::cppu::queryInterface
  64                 (   rType
  65                     ,   static_cast<lang::XTypeProvider*> ( this )
  66                     ,   static_cast<io::XStream*> ( this )
  67                     ,   static_cast<embed::XExtendedStorageStream*> ( this )
  68                     ,   static_cast<lang::XComponent*> ( this ) );
  69
  70     if ( aReturn.hasValue() )
  71         return aReturn ;
  72
  73     if ( m_xSeekable.is() )
  74     {
  75         aReturn = ::cppu::queryInterface
  76                 (   rType
  77                     ,   static_cast<io::XSeekable*> ( this ) );
  78
  79         if ( aReturn.hasValue() )
  80             return aReturn ;
  81     }
  82
  83     if ( m_xInputStream.is() )
  84     {
  85         aReturn = ::cppu::queryInterface
  86                 (   rType
  87                     ,   static_cast<io::XInputStream*> ( this ) );
  88
  89         if ( aReturn.hasValue() )
  90             return aReturn ;
  91     }
  92     if ( m_xOutputStream.is() )
  93     {
  94         aReturn = ::cppu::queryInterface
  95                 (   rType
  96                     ,   static_cast<io::XOutputStream*> ( this ) );
  97
  98         if ( aReturn.hasValue() )
  99             return aReturn ;
 100     }
 101     if ( m_xTruncate.is() )
 102     {
 103         aReturn = ::cppu::queryInterface
 104                 (   rType
 105                     ,   static_cast<io::XTruncate*> ( this ) );
 106
 107         if ( aReturn.hasValue() )
 108             return aReturn ;
 109     }
 110     if ( m_xAsyncOutputMonitor.is() )
 111     {
 112         aReturn = ::cppu::queryInterface
 113                 (   rType
 114                     ,   static_cast<io::XAsyncOutputMonitor*> ( this ) );
 115
 116         if ( aReturn.hasValue() )
 117             return aReturn ;
 118     }
 119
 120     return OWeakObject::queryInterface( rType );
 121 }
 122
 123 void SAL_CALL OFSStreamContainer::acquire()
 124         noexcept
 125 {
 126     OWeakObject::acquire();
 127 }
 128
 129 void SAL_CALL OFSStreamContainer::release()
 130         noexcept
 131 {
 132     OWeakObject::release();
 133 }
 134
 135 //  XTypeProvider
 136 uno::Sequence< uno::Type > SAL_CALL OFSStreamContainer::getTypes()
 137 {
 138     std::scoped_lock aGuard( m_aMutex );
 139     if ( !m_aTypes.hasElements() )
 140     {
 141         std::vector<uno::Type> tmp
 142         {
 143             cppu::UnoType<lang::XTypeProvider>::get(),
 144             cppu::UnoType<embed::XExtendedStorageStream>::get()
 145         };
 146
 147         if ( m_xSeekable.is() )
 148             tmp.push_back(cppu::UnoType<io::XSeekable>::get());
 149         if ( m_xInputStream.is() )
 150             tmp.push_back(cppu::UnoType<io::XInputStream>::get());
 151         if ( m_xOutputStream.is() )
 152             tmp.push_back(cppu::UnoType<io::XOutputStream>::get());
 153         if ( m_xTruncate.is() )
 154             tmp.push_back(cppu::UnoType<io::XTruncate>::get());
 155         if ( m_xAsyncOutputMonitor.is() )
 156             tmp.push_back(cppu::UnoType<io::XAsyncOutputMonitor>::get());
 157
 158         m_aTypes = comphelper::containerToSequence(tmp);
 159     }
 160     return m_aTypes;
 161 }
 162
 163 uno::Sequence< sal_Int8 > SAL_CALL OFSStreamContainer::getImplementationId()
 164 {
 165     return css::uno::Sequence<sal_Int8>();
 166 }
 167
 168 // XStream
 169 uno::Reference< io::XInputStream > SAL_CALL OFSStreamContainer::getInputStream()
 170 {
 171     std::scoped_lock aGuard( m_aMutex );
 172
 173     if ( m_bDisposed )
 174         throw lang::DisposedException();
 175
 176     if ( !m_xStream.is() )
 177         throw uno::RuntimeException();
 178
 179     if ( m_xInputStream.is() )
 180         return uno::Reference< io::XInputStream >( static_cast< io::XInputStream* >( this ) );
 181
 182     return uno::Reference< io::XInputStream >();
 183 }
 184
 185 uno::Reference< io::XOutputStream > SAL_CALL OFSStreamContainer::getOutputStream()
 186 {
 187     std::scoped_lock aGuard( m_aMutex );
 188
 189     if ( m_bDisposed )
 190         throw lang::DisposedException();
 191
 192     if ( !m_xStream.is() )
 193         throw uno::RuntimeException();
 194
 195     if ( m_xOutputStream.is() )
 196         return uno::Reference< io::XOutputStream >( static_cast< io::XOutputStream* >( this ) );
 197
 198     return uno::Reference< io::XOutputStream >();
 199 }
 200
 201 // XComponent
 202 void SAL_CALL OFSStreamContainer::dispose()
 203 {
 204     std::unique_lock aGuard( m_aMutex );
 205
 206     if ( m_bDisposed )
 207         return;
 208
 209     if ( !m_xStream.is() )
 210         throw uno::RuntimeException();
 211
 212     if ( m_xInputStream.is() && !m_bInputClosed )
 213     {
 214         m_xInputStream->closeInput();
 215         m_bInputClosed = true;
 216     }
 217
 218     if ( m_xOutputStream.is() && !m_bOutputClosed )
 219     {
 220         m_xOutputStream->closeOutput();
 221         m_bOutputClosed = true;
 222     }
 223
 224     lang::EventObject aSource( getXWeak() );
 225     m_aListenersContainer.disposeAndClear( aGuard, aSource );
 226     m_bDisposed = true;
 227 }
 228
 229 void SAL_CALL OFSStreamContainer::addEventListener( const uno::Reference< lang::XEventListener >& xListener )
 230 {
 231     std::unique_lock aGuard( m_aMutex );
 232
 233     if ( m_bDisposed )
 234         throw lang::DisposedException();
 235
 236     m_aListenersContainer.addInterface( aGuard, xListener );
 237 }
 238
 239 void SAL_CALL OFSStreamContainer::removeEventListener( const uno::Reference< lang::XEventListener >& xListener )
 240 {
 241     std::unique_lock aGuard( m_aMutex );
 242
 243     if ( m_bDisposed )
 244         throw lang::DisposedException();
 245
 246     m_aListenersContainer.removeInterface( aGuard, xListener );
 247 }
 248
 249
 250 // XSeekable
 251 void SAL_CALL OFSStreamContainer::seek( sal_Int64 location )
 252 {
 253     std::scoped_lock aGuard( m_aMutex );
 254
 255     if ( m_bDisposed )
 256         throw lang::DisposedException();
 257
 258     if ( !m_xStream.is() || !m_xSeekable.is() )
 259         throw uno::RuntimeException();
 260
 261     m_xSeekable->seek( location );
 262 }
 263
 264 sal_Int64 SAL_CALL OFSStreamContainer::getPosition()
 265 {
 266     std::scoped_lock aGuard( m_aMutex );
 267
 268     if ( m_bDisposed )
 269         throw lang::DisposedException();
 270
 271     if ( !m_xStream.is() || !m_xSeekable.is() )
 272         throw uno::RuntimeException();
 273
 274     return m_xSeekable->getPosition();
 275 }
 276
 277 sal_Int64 SAL_CALL OFSStreamContainer::getLength()
 278 {
 279     std::scoped_lock aGuard( m_aMutex );
 280
 281     if ( m_bDisposed )
 282         throw lang::DisposedException();
 283
 284     if ( !m_xStream.is() || !m_xSeekable.is() )
 285         throw uno::RuntimeException();
 286
 287     return m_xSeekable->getLength();
 288 }
 289
 290
 291 // XInputStream
 292 sal_Int32 SAL_CALL OFSStreamContainer::readBytes( uno::Sequence< sal_Int8 >& aData, sal_Int32 nBytesToRead )
 293 {
 294     std::scoped_lock aGuard( m_aMutex );
 295
 296     if ( m_bDisposed )
 297         throw lang::DisposedException();
 298
 299     if ( !m_xStream.is() || !m_xInputStream.is() )
 300         throw uno::RuntimeException();
 301
 302     return m_xInputStream->readBytes( aData, nBytesToRead );
 303 }
 304
 305 sal_Int32 SAL_CALL OFSStreamContainer::readSomeBytes( uno::Sequence< sal_Int8 >& aData, sal_Int32 nMaxBytesToRead )
 306 {
 307     std::scoped_lock aGuard( m_aMutex );
 308
 309     if ( m_bDisposed )
 310         throw lang::DisposedException();
 311
 312     if ( !m_xStream.is() || !m_xInputStream.is() )
 313         throw uno::RuntimeException();
 314
 315     return m_xInputStream->readSomeBytes( aData, nMaxBytesToRead );
 316 }
 317
 318 void SAL_CALL OFSStreamContainer::skipBytes( sal_Int32 nBytesToSkip )
 319 {
 320     std::scoped_lock aGuard( m_aMutex );
 321
 322     if ( m_bDisposed )
 323         throw lang::DisposedException();
 324
 325     if ( !m_xStream.is() || !m_xInputStream.is() )
 326         throw uno::RuntimeException();
 327
 328     m_xInputStream->skipBytes( nBytesToSkip );
 329 }
 330
 331 sal_Int32 SAL_CALL OFSStreamContainer::available()
 332 {
 333     std::scoped_lock aGuard( m_aMutex );
 334
 335     if ( m_bDisposed )
 336         throw lang::DisposedException();
 337
 338     if ( !m_xStream.is() || !m_xInputStream.is() )
 339         throw uno::RuntimeException();
 340
 341     return m_xInputStream->available();
 342 }
 343
 344 void SAL_CALL OFSStreamContainer::closeInput()
 345 {
 346     {
 347         std::scoped_lock aGuard( m_aMutex );
 348
 349         if ( m_bDisposed )
 350             throw lang::DisposedException();
 351
 352         if ( !m_xStream.is() || !m_xInputStream.is() )
 353             throw uno::RuntimeException();
 354
 355         if ( m_xInputStream.is() )
 356         {
 357             m_xInputStream->closeInput();
 358             m_bInputClosed = true;
 359         }
 360         if ( !m_bOutputClosed )
 361             return;
 362     }
 363
 364     dispose();
 365 }
 366
 367 // XOutputStream
 368 void SAL_CALL OFSStreamContainer::writeBytes( const uno::Sequence< sal_Int8 >& aData )
 369 {
 370     std::scoped_lock aGuard( m_aMutex );
 371
 372     if ( m_bDisposed )
 373         throw lang::DisposedException();
 374
 375     if ( !m_xStream.is() || !m_xOutputStream.is() )
 376         throw uno::RuntimeException();
 377
 378     return m_xOutputStream->writeBytes( aData );
 379 }
 380
 381 void SAL_CALL OFSStreamContainer::flush()
 382 {
 383     std::scoped_lock aGuard( m_aMutex );
 384
 385     if ( m_bDisposed )
 386         throw lang::DisposedException();
 387
 388     if ( !m_xStream.is() || !m_xOutputStream.is() )
 389         throw uno::RuntimeException();
 390
 391     return m_xOutputStream->flush();
 392 }
 393
 394 void SAL_CALL OFSStreamContainer::closeOutput()
 395 {
 396     {
 397         std::scoped_lock aGuard( m_aMutex );
 398
 399         if ( m_bDisposed )
 400             throw lang::DisposedException();
 401
 402         if ( !m_xStream.is() || !m_xOutputStream.is() )
 403             throw uno::RuntimeException();
 404
 405         if ( m_xOutputStream.is() )
 406         {
 407             m_xOutputStream->closeOutput();
 408             m_bOutputClosed = true;
 409         }
 410         if ( !m_bInputClosed )
 411             return;
 412     }
 413     dispose();
 414 }
 415
 416
 417 // XTruncate
 418 void SAL_CALL OFSStreamContainer::truncate()
 419 {
 420     std::scoped_lock aGuard( m_aMutex );
 421
 422     if ( m_bDisposed )
 423         throw lang::DisposedException();
 424
 425     if ( !m_xStream.is() || !m_xTruncate.is() )
 426         throw uno::RuntimeException();
 427
 428     m_xTruncate->truncate();
 429 }
 430
 431
 432 // XAsyncOutputMonitor
 433 void SAL_CALL OFSStreamContainer::waitForCompletion()
 434 {
 435     std::scoped_lock aGuard( m_aMutex );
 436
 437     if ( m_bDisposed )
 438         throw lang::DisposedException();
 439
 440     if ( !m_xStream.is() || !m_xAsyncOutputMonitor.is() )
 441         throw uno::RuntimeException();
 442
 443     m_xAsyncOutputMonitor->waitForCompletion();
 444 }
 445
 446
 447 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */