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         noexcept
  83 {
  84     ::cppu::OWeakObject::acquire();
  85 }
  86
  87 void SAL_CALL OFSInputStreamContainer::release()
  88         noexcept
  89 {
  90     ::cppu::OWeakObject::release();
  91 }
  92
  93 sal_Int32 SAL_CALL OFSInputStreamContainer::readBytes( uno::Sequence< sal_Int8 >& aData, sal_Int32 nBytesToRead )
  94 {
  95     std::scoped_lock 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     std::scoped_lock 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     std::scoped_lock 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     std::scoped_lock 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     {
 148         std::scoped_lock aGuard( m_aMutex );
 149
 150         if ( m_bDisposed )
 151             throw lang::DisposedException();
 152
 153         if ( !m_xInputStream.is() )
 154             throw uno::RuntimeException();
 155     }
 156     dispose();
 157 }
 158
 159 uno::Reference< io::XInputStream > SAL_CALL OFSInputStreamContainer::getInputStream()
 160 {
 161     std::scoped_lock aGuard( m_aMutex );
 162
 163     if ( m_bDisposed )
 164         throw lang::DisposedException();
 165
 166     if ( !m_xInputStream.is() )
 167         return uno::Reference< io::XInputStream >();
 168
 169     return this;
 170 }
 171
 172 uno::Reference< io::XOutputStream > SAL_CALL OFSInputStreamContainer::getOutputStream()
 173 {
 174     std::scoped_lock aGuard( m_aMutex );
 175
 176     if ( m_bDisposed )
 177         throw lang::DisposedException();
 178
 179     return uno::Reference< io::XOutputStream >();
 180 }
 181
 182 void SAL_CALL OFSInputStreamContainer::seek( sal_Int64 location )
 183 {
 184     std::scoped_lock aGuard( m_aMutex );
 185
 186     if ( m_bDisposed )
 187         throw lang::DisposedException();
 188
 189     if ( !m_xSeekable.is() )
 190         throw uno::RuntimeException();
 191
 192     m_xSeekable->seek( location );
 193 }
 194
 195 sal_Int64 SAL_CALL OFSInputStreamContainer::getPosition()
 196 {
 197     std::scoped_lock aGuard( m_aMutex );
 198
 199     if ( m_bDisposed )
 200         throw lang::DisposedException();
 201
 202     if ( !m_xSeekable.is() )
 203         throw uno::RuntimeException();
 204
 205     return m_xSeekable->getPosition();
 206 }
 207
 208 sal_Int64 SAL_CALL OFSInputStreamContainer::getLength()
 209 {
 210     std::scoped_lock aGuard( m_aMutex );
 211
 212     if ( m_bDisposed )
 213         throw lang::DisposedException();
 214
 215     if ( !m_xSeekable.is() )
 216         throw uno::RuntimeException();
 217
 218     return m_xSeekable->getLength();
 219 }
 220
 221 void SAL_CALL OFSInputStreamContainer::dispose(  )
 222 {
 223     std::unique_lock aGuard( m_aMutex );
 224
 225     if ( m_bDisposed )
 226         return;
 227
 228     if ( !m_xInputStream.is() )
 229         throw uno::RuntimeException();
 230
 231     m_xInputStream->closeInput();
 232
 233     lang::EventObject aSource( getXWeak() );
 234     m_aListenersContainer.disposeAndClear( aGuard, aSource );
 235
 236     m_bDisposed = true;
 237 }
 238
 239 void SAL_CALL OFSInputStreamContainer::addEventListener( 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.addInterface( aGuard, xListener );
 247 }
 248
 249 void SAL_CALL OFSInputStreamContainer::removeEventListener( const uno::Reference< lang::XEventListener >& xListener )
 250 {
 251     std::unique_lock aGuard( m_aMutex );
 252
 253     if ( m_bDisposed )
 254         throw lang::DisposedException();
 255
 256     m_aListenersContainer.removeInterface( aGuard, xListener );
 257 }
 258
 259
 260 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */