svl/source/fsstor/oinputstreamcontainer.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 #include "oinputstreamcontainer.hxx"
  22 #include <cppuhelper/typeprovider.hxx>
  23 #include <cppuhelper/queryinterface.hxx>
  24
  25 using namespace ::com::sun::star;
  26
  27 OFSInputStreamContainer::OFSInputStreamContainer( const uno::Reference< io::XInputStream >& xStream )
  28 : m_xInputStream( xStream )
  29 , m_xSeekable( xStream, uno::UNO_QUERY )
  30 , m_bSeekable( false )
  31 , m_bDisposed( false )
  32 , m_pListenersContainer( NULL )
  33 {
  34     m_bSeekable = m_xSeekable.is();
  35 }
  36
  37 OFSInputStreamContainer::~OFSInputStreamContainer()
  38 {
  39     if ( m_pListenersContainer )
  40     {
  41         delete m_pListenersContainer;
  42         m_pListenersContainer = NULL;
  43     }
  44 }
  45
  46 uno::Sequence< uno::Type > SAL_CALL OFSInputStreamContainer::getTypes()
  47         throw ( uno::RuntimeException, std::exception )
  48 {
  49     static ::cppu::OTypeCollection* pTypeCollection = NULL ;
  50
  51     if ( pTypeCollection == NULL )
  52     {
  53         ::osl::MutexGuard aGuard( m_aMutex ) ;
  54
  55         if ( pTypeCollection == NULL )
  56         {
  57             if ( m_bSeekable )
  58             {
  59                 static ::cppu::OTypeCollection aTypeCollection(
  60                         cppu::UnoType<io::XStream>::get(),
  61                         cppu::UnoType<io::XInputStream>::get(),
  62                         cppu::UnoType<io::XSeekable>::get());
  63
  64                 pTypeCollection = &aTypeCollection ;
  65             }
  66             else
  67             {
  68                 static ::cppu::OTypeCollection aTypeCollection(
  69                         cppu::UnoType<io::XStream>::get(),
  70                         cppu::UnoType<io::XInputStream>::get());
  71
  72                 pTypeCollection = &aTypeCollection ;
  73             }
  74         }
  75     }
  76
  77     return pTypeCollection->getTypes() ;
  78
  79 }
  80
  81 uno::Any SAL_CALL OFSInputStreamContainer::queryInterface( const uno::Type& rType )
  82         throw( uno::RuntimeException, std::exception )
  83 {
  84     // Attention:
  85     //  Don't use mutex or guard in this method!!! Is a method of XInterface.
  86
  87     uno::Any aReturn;
  88     if ( m_bSeekable )
  89         aReturn = uno::Any( ::cppu::queryInterface( rType,
  90                                            static_cast< io::XStream* >( this ),
  91                                            static_cast< io::XInputStream* >( this ),
  92                                            static_cast< io::XSeekable* >( this ) ) );
  93     else
  94         aReturn = uno::Any( ::cppu::queryInterface( rType,
  95                                            static_cast< io::XStream* >( this ),
  96                                            static_cast< io::XInputStream* >( this ) ) );
  97
  98     if ( aReturn.hasValue() )
  99         return aReturn ;
 100
 101     return ::cppu::OWeakObject::queryInterface( rType ) ;
 102 }
 103
 104 void SAL_CALL OFSInputStreamContainer::acquire()
 105         throw()
 106 {
 107     ::cppu::OWeakObject::acquire();
 108 }
 109
 110 void SAL_CALL OFSInputStreamContainer::release()
 111         throw()
 112 {
 113     ::cppu::OWeakObject::release();
 114 }
 115
 116 sal_Int32 SAL_CALL OFSInputStreamContainer::readBytes( uno::Sequence< sal_Int8 >& aData, sal_Int32 nBytesToRead )
 117         throw ( io::NotConnectedException,
 118                 io::BufferSizeExceededException,
 119                 io::IOException,
 120                 uno::RuntimeException, std::exception )
 121 {
 122     ::osl::MutexGuard aGuard( m_aMutex );
 123
 124     if ( m_bDisposed )
 125         throw lang::DisposedException();
 126
 127     if ( !m_xInputStream.is() )
 128         throw uno::RuntimeException();
 129
 130     return m_xInputStream->readBytes( aData, nBytesToRead );
 131 }
 132
 133 sal_Int32 SAL_CALL OFSInputStreamContainer::readSomeBytes( uno::Sequence< sal_Int8 >& aData, sal_Int32 nMaxBytesToRead )
 134         throw ( io::NotConnectedException,
 135                 io::BufferSizeExceededException,
 136                 io::IOException,
 137                 uno::RuntimeException, std::exception )
 138 {
 139     ::osl::MutexGuard aGuard( m_aMutex );
 140
 141     if ( m_bDisposed )
 142         throw lang::DisposedException();
 143
 144     if ( !m_xInputStream.is() )
 145         throw uno::RuntimeException();
 146
 147     return m_xInputStream->readSomeBytes( aData, nMaxBytesToRead );
 148 }
 149
 150 void SAL_CALL OFSInputStreamContainer::skipBytes( sal_Int32 nBytesToSkip )
 151         throw ( io::NotConnectedException,
 152                 io::BufferSizeExceededException,
 153                 io::IOException,
 154                 uno::RuntimeException, std::exception )
 155 {
 156     ::osl::MutexGuard aGuard( m_aMutex );
 157
 158     if ( m_bDisposed )
 159         throw lang::DisposedException();
 160
 161     if ( !m_xInputStream.is() )
 162         throw uno::RuntimeException();
 163
 164     m_xInputStream->skipBytes( nBytesToSkip );
 165 }
 166
 167 sal_Int32 SAL_CALL OFSInputStreamContainer::available(  )
 168         throw ( io::NotConnectedException,
 169                 io::IOException,
 170                 uno::RuntimeException, std::exception )
 171 {
 172     ::osl::MutexGuard aGuard( m_aMutex );
 173
 174     if ( m_bDisposed )
 175         throw lang::DisposedException();
 176
 177     if ( !m_xInputStream.is() )
 178         throw uno::RuntimeException();
 179
 180     return m_xInputStream->available();
 181 }
 182
 183 void SAL_CALL OFSInputStreamContainer::closeInput(  )
 184         throw ( io::NotConnectedException,
 185                 io::IOException,
 186                 uno::RuntimeException, std::exception )
 187 {
 188     ::osl::MutexGuard aGuard( m_aMutex );
 189
 190     if ( m_bDisposed )
 191         throw lang::DisposedException();
 192
 193     if ( !m_xInputStream.is() )
 194         throw uno::RuntimeException();
 195
 196     dispose();
 197 }
 198
 199 uno::Reference< io::XInputStream > SAL_CALL OFSInputStreamContainer::getInputStream()
 200         throw ( uno::RuntimeException, std::exception )
 201 {
 202     ::osl::MutexGuard aGuard( m_aMutex );
 203
 204     if ( m_bDisposed )
 205         throw lang::DisposedException();
 206
 207     if ( !m_xInputStream.is() )
 208         return uno::Reference< io::XInputStream >();
 209
 210     return uno::Reference< io::XInputStream >( static_cast< io::XInputStream* >( this ), uno::UNO_QUERY );
 211 }
 212
 213 uno::Reference< io::XOutputStream > SAL_CALL OFSInputStreamContainer::getOutputStream()
 214         throw ( uno::RuntimeException, std::exception )
 215 {
 216     ::osl::MutexGuard aGuard( m_aMutex );
 217
 218     if ( m_bDisposed )
 219         throw lang::DisposedException();
 220
 221     return uno::Reference< io::XOutputStream >();
 222 }
 223
 224 void SAL_CALL OFSInputStreamContainer::seek( sal_Int64 location )
 225         throw ( lang::IllegalArgumentException,
 226                 io::IOException,
 227                 uno::RuntimeException, std::exception )
 228 {
 229     ::osl::MutexGuard aGuard( m_aMutex );
 230
 231     if ( m_bDisposed )
 232         throw lang::DisposedException();
 233
 234     if ( !m_xSeekable.is() )
 235         throw uno::RuntimeException();
 236
 237     m_xSeekable->seek( location );
 238 }
 239
 240 sal_Int64 SAL_CALL OFSInputStreamContainer::getPosition()
 241         throw ( io::IOException,
 242                 uno::RuntimeException, std::exception)
 243 {
 244     ::osl::MutexGuard aGuard( m_aMutex );
 245
 246     if ( m_bDisposed )
 247         throw lang::DisposedException();
 248
 249     if ( !m_xSeekable.is() )
 250         throw uno::RuntimeException();
 251
 252     return m_xSeekable->getPosition();
 253 }
 254
 255 sal_Int64 SAL_CALL OFSInputStreamContainer::getLength()
 256         throw ( io::IOException,
 257                 uno::RuntimeException, std::exception )
 258 {
 259     ::osl::MutexGuard aGuard( m_aMutex );
 260
 261     if ( m_bDisposed )
 262         throw lang::DisposedException();
 263
 264     if ( !m_xSeekable.is() )
 265         throw uno::RuntimeException();
 266
 267     return m_xSeekable->getLength();
 268 }
 269
 270 void SAL_CALL OFSInputStreamContainer::dispose(  )
 271         throw ( uno::RuntimeException, std::exception )
 272 {
 273     ::osl::MutexGuard aGuard( m_aMutex );
 274
 275     if ( m_bDisposed )
 276         throw lang::DisposedException();
 277
 278     if ( !m_xInputStream.is() )
 279         throw uno::RuntimeException();
 280
 281     m_xInputStream->closeInput();
 282
 283     if ( m_pListenersContainer )
 284     {
 285         lang::EventObject aSource( static_cast< ::cppu::OWeakObject*>( this ) );
 286         m_pListenersContainer->disposeAndClear( aSource );
 287     }
 288
 289     m_bDisposed = true;
 290 }
 291
 292 void SAL_CALL OFSInputStreamContainer::addEventListener( const uno::Reference< lang::XEventListener >& xListener )
 293         throw ( uno::RuntimeException, std::exception )
 294 {
 295     ::osl::MutexGuard aGuard( m_aMutex );
 296
 297     if ( m_bDisposed )
 298         throw lang::DisposedException();
 299
 300     if ( !m_pListenersContainer )
 301         m_pListenersContainer = new ::cppu::OInterfaceContainerHelper( m_aMutex );
 302
 303     m_pListenersContainer->addInterface( xListener );
 304 }
 305
 306 void SAL_CALL OFSInputStreamContainer::removeEventListener( const uno::Reference< lang::XEventListener >& xListener )
 307         throw ( uno::RuntimeException, std::exception )
 308 {
 309     ::osl::MutexGuard aGuard( m_aMutex );
 310
 311     if ( m_bDisposed )
 312         throw lang::DisposedException();
 313
 314     if ( m_pListenersContainer )
 315         m_pListenersContainer->removeInterface( xListener );
 316 }
 317
 318
 319
 320 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */