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 {
  33     m_bSeekable = m_xSeekable.is();
  34 }
  35
  36 OFSInputStreamContainer::~OFSInputStreamContainer()
  37 {
  38 }
  39
  40 uno::Sequence< uno::Type > SAL_CALL OFSInputStreamContainer::getTypes()
  41 {
  42     if (m_bSeekable)
  43     {
  44         static cppu::OTypeCollection aTypeCollection(cppu::UnoType<io::XStream>::get(),
  45                                                      cppu::UnoType<io::XInputStream>::get(),
  46                                                      cppu::UnoType<io::XSeekable>::get());
  47
  48         return aTypeCollection.getTypes();
  49     }
  50     else
  51     {
  52         static cppu::OTypeCollection aTypeCollection(cppu::UnoType<io::XStream>::get(),
  53                                                      cppu::UnoType<io::XInputStream>::get());
  54
  55         return aTypeCollection.getTypes();
  56     }
  57 }
  58
  59 uno::Any SAL_CALL OFSInputStreamContainer::queryInterface( const uno::Type& rType )
  60 {
  61     // Attention:
  62     //  Don't use mutex or guard in this method!!! Is a method of XInterface.
  63
  64     uno::Any aReturn;
  65     if ( m_bSeekable )
  66         aReturn = ::cppu::queryInterface( rType,
  67                                            static_cast< io::XStream* >( this ),
  68                                            static_cast< io::XInputStream* >( this ),
  69                                            static_cast< io::XSeekable* >( this ) );
  70     else
  71         aReturn = ::cppu::queryInterface( rType,
  72                                            static_cast< io::XStream* >( this ),
  73                                            static_cast< io::XInputStream* >( this ) );
  74
  75     if ( aReturn.hasValue() )
  76         return aReturn ;
  77
  78     return ::cppu::OWeakObject::queryInterface( rType ) ;
  79 }
  80
  81 void SAL_CALL OFSInputStreamContainer::acquire()
  82         throw()
  83 {
  84     ::cppu::OWeakObject::acquire();
  85 }
  86
  87 void SAL_CALL OFSInputStreamContainer::release()
  88         throw()
  89 {
  90     ::cppu::OWeakObject::release();
  91 }
  92
  93 sal_Int32 SAL_CALL OFSInputStreamContainer::readBytes( uno::Sequence< sal_Int8 >& aData, sal_Int32 nBytesToRead )
  94 {
  95     ::osl::MutexGuard aGuard( m_aMutex );
  96
  97     if ( m_bDisposed )
  98         throw lang::DisposedException();
  99
 100     if ( !m_xInputStream.is() )
 101         throw uno::RuntimeException();
 102
 103     return m_xInputStream->readBytes( aData, nBytesToRead );
 104 }
 105
 106 sal_Int32 SAL_CALL OFSInputStreamContainer::readSomeBytes( uno::Sequence< sal_Int8 >& aData, sal_Int32 nMaxBytesToRead )
 107 {
 108     ::osl::MutexGuard aGuard( m_aMutex );
 109
 110     if ( m_bDisposed )
 111         throw lang::DisposedException();
 112
 113     if ( !m_xInputStream.is() )
 114         throw uno::RuntimeException();
 115
 116     return m_xInputStream->readSomeBytes( aData, nMaxBytesToRead );
 117 }
 118
 119 void SAL_CALL OFSInputStreamContainer::skipBytes( sal_Int32 nBytesToSkip )
 120 {
 121     ::osl::MutexGuard aGuard( m_aMutex );
 122
 123     if ( m_bDisposed )
 124         throw lang::DisposedException();
 125
 126     if ( !m_xInputStream.is() )
 127         throw uno::RuntimeException();
 128
 129     m_xInputStream->skipBytes( nBytesToSkip );
 130 }
 131
 132 sal_Int32 SAL_CALL OFSInputStreamContainer::available(  )
 133 {
 134     ::osl::MutexGuard aGuard( m_aMutex );
 135
 136     if ( m_bDisposed )
 137         throw lang::DisposedException();
 138
 139     if ( !m_xInputStream.is() )
 140         throw uno::RuntimeException();
 141
 142     return m_xInputStream->available();
 143 }
 144
 145 void SAL_CALL OFSInputStreamContainer::closeInput(  )
 146 {
 147     ::osl::MutexGuard aGuard( m_aMutex );
 148
 149     if ( m_bDisposed )
 150         throw lang::DisposedException();
 151
 152     if ( !m_xInputStream.is() )
 153         throw uno::RuntimeException();
 154
 155     dispose();
 156 }
 157
 158 uno::Reference< io::XInputStream > SAL_CALL OFSInputStreamContainer::getInputStream()
 159 {
 160     ::osl::MutexGuard aGuard( m_aMutex );
 161
 162     if ( m_bDisposed )
 163         throw lang::DisposedException();
 164
 165     if ( !m_xInputStream.is() )
 166         return uno::Reference< io::XInputStream >();
 167
 168     return uno::Reference< io::XInputStream >( static_cast< io::XInputStream* >( this ), uno::UNO_QUERY );
 169 }
 170
 171 uno::Reference< io::XOutputStream > SAL_CALL OFSInputStreamContainer::getOutputStream()
 172 {
 173     ::osl::MutexGuard aGuard( m_aMutex );
 174
 175     if ( m_bDisposed )
 176         throw lang::DisposedException();
 177
 178     return uno::Reference< io::XOutputStream >();
 179 }
 180
 181 void SAL_CALL OFSInputStreamContainer::seek( sal_Int64 location )
 182 {
 183     ::osl::MutexGuard aGuard( m_aMutex );
 184
 185     if ( m_bDisposed )
 186         throw lang::DisposedException();
 187
 188     if ( !m_xSeekable.is() )
 189         throw uno::RuntimeException();
 190
 191     m_xSeekable->seek( location );
 192 }
 193
 194 sal_Int64 SAL_CALL OFSInputStreamContainer::getPosition()
 195 {
 196     ::osl::MutexGuard aGuard( m_aMutex );
 197
 198     if ( m_bDisposed )
 199         throw lang::DisposedException();
 200
 201     if ( !m_xSeekable.is() )
 202         throw uno::RuntimeException();
 203
 204     return m_xSeekable->getPosition();
 205 }
 206
 207 sal_Int64 SAL_CALL OFSInputStreamContainer::getLength()
 208 {
 209     ::osl::MutexGuard aGuard( m_aMutex );
 210
 211     if ( m_bDisposed )
 212         throw lang::DisposedException();
 213
 214     if ( !m_xSeekable.is() )
 215         throw uno::RuntimeException();
 216
 217     return m_xSeekable->getLength();
 218 }
 219
 220 void SAL_CALL OFSInputStreamContainer::dispose(  )
 221 {
 222     ::osl::MutexGuard aGuard( m_aMutex );
 223
 224     if ( m_bDisposed )
 225         throw lang::DisposedException();
 226
 227     if ( !m_xInputStream.is() )
 228         throw uno::RuntimeException();
 229
 230     m_xInputStream->closeInput();
 231
 232     if ( m_pListenersContainer )
 233     {
 234         lang::EventObject aSource( static_cast< ::cppu::OWeakObject*>( this ) );
 235         m_pListenersContainer->disposeAndClear( aSource );
 236     }
 237
 238     m_bDisposed = true;
 239 }
 240
 241 void SAL_CALL OFSInputStreamContainer::addEventListener( const uno::Reference< lang::XEventListener >& xListener )
 242 {
 243     ::osl::MutexGuard aGuard( m_aMutex );
 244
 245     if ( m_bDisposed )
 246         throw lang::DisposedException();
 247
 248     if ( !m_pListenersContainer )
 249         m_pListenersContainer.reset( new ::comphelper::OInterfaceContainerHelper2( m_aMutex ) );
 250
 251     m_pListenersContainer->addInterface( xListener );
 252 }
 253
 254 void SAL_CALL OFSInputStreamContainer::removeEventListener( const uno::Reference< lang::XEventListener >& xListener )
 255 {
 256     ::osl::MutexGuard aGuard( m_aMutex );
 257
 258     if ( m_bDisposed )
 259         throw lang::DisposedException();
 260
 261     if ( m_pListenersContainer )
 262         m_pListenersContainer->removeInterface( xListener );
 263 }
 264
 265
 266 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */