comphelper/source/streaming/seekableinput.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 <sal/config.h>
  21
  22 #include <com/sun/star/io/IOException.hpp>
  23 #include <com/sun/star/io/NotConnectedException.hpp>
  24 #include <com/sun/star/io/TempFile.hpp>
  25 #include <com/sun/star/io/XOutputStream.hpp>
  26
  27 #include <com/sun/star/lang/IllegalArgumentException.hpp>
  28
  29 #include <comphelper/seekableinput.hxx>
  30 #include <utility>
  31
  32 using namespace ::com::sun::star;
  33
  34 namespace comphelper
  35 {
  36
  37 const sal_Int32 nConstBufferSize = 32000;
  38
  39
  40 static void copyInputToOutput_Impl( const uno::Reference< io::XInputStream >& xIn,
  41                             const uno::Reference< io::XOutputStream >& xOut )
  42 {
  43     sal_Int32 nRead;
  44     uno::Sequence< sal_Int8 > aSequence( nConstBufferSize );
  45
  46     do
  47     {
  48         nRead = xIn->readBytes( aSequence, nConstBufferSize );
  49         if ( nRead < nConstBufferSize )
  50         {
  51             uno::Sequence< sal_Int8 > aTempBuf( aSequence.getConstArray(), nRead );
  52             xOut->writeBytes( aTempBuf );
  53         }
  54         else
  55             xOut->writeBytes( aSequence );
  56     }
  57     while ( nRead == nConstBufferSize );
  58 }
  59
  60
  61 OSeekableInputWrapper::OSeekableInputWrapper(
  62             uno::Reference< io::XInputStream > xInStream,
  63             uno::Reference< uno::XComponentContext > xContext )
  64 : m_xContext(std::move( xContext ))
  65 , m_xOriginalStream(std::move( xInStream ))
  66 {
  67     if ( !m_xContext.is() )
  68         throw lang::IllegalArgumentException(u"no component context"_ustr, *this, 1);
  69 }
  70
  71
  72 OSeekableInputWrapper::~OSeekableInputWrapper()
  73 {
  74 }
  75
  76
  77 uno::Reference< io::XInputStream > OSeekableInputWrapper::CheckSeekableCanWrap(
  78                             const uno::Reference< io::XInputStream >& xInStream,
  79                             const uno::Reference< uno::XComponentContext >& rxContext )
  80 {
  81     // check that the stream is seekable and just wrap it if it is not
  82     uno::Reference< io::XSeekable > xSeek( xInStream, uno::UNO_QUERY );
  83     if ( xSeek.is() )
  84         return xInStream;
  85
  86     return new OSeekableInputWrapper(xInStream, rxContext);
  87 }
  88
  89
  90 void OSeekableInputWrapper::PrepareCopy_Impl()
  91 {
  92     if ( !m_xCopyInput.is() )
  93     {
  94         if ( !m_xContext.is() )
  95             throw uno::RuntimeException(u"no component context"_ustr);
  96
  97         uno::Reference< io::XOutputStream > xTempOut(
  98                 io::TempFile::create(m_xContext),
  99                 uno::UNO_QUERY_THROW );
 100
 101         copyInputToOutput_Impl( m_xOriginalStream, xTempOut );
 102         xTempOut->closeOutput();
 103
 104         uno::Reference< io::XSeekable > xTempSeek( xTempOut, uno::UNO_QUERY );
 105         if ( xTempSeek.is() )
 106         {
 107             xTempSeek->seek( 0 );
 108             m_xCopyInput.set( xTempOut, uno::UNO_QUERY );
 109             if ( m_xCopyInput.is() )
 110             {
 111                 m_xCopySeek = std::move(xTempSeek);
 112                 m_pCopyByteReader = dynamic_cast<comphelper::ByteReader*>(xTempOut.get());
 113                 assert(m_pCopyByteReader);
 114             }
 115         }
 116     }
 117
 118     if ( !m_xCopyInput.is() )
 119         throw io::IOException(u"no m_xCopyInput"_ustr);
 120 }
 121
 122 // XInputStream
 123
 124 sal_Int32 SAL_CALL OSeekableInputWrapper::readBytes( uno::Sequence< sal_Int8 >& aData, sal_Int32 nBytesToRead )
 125 {
 126     std::scoped_lock aGuard( m_aMutex );
 127
 128     if ( !m_xOriginalStream.is() )
 129         throw io::NotConnectedException();
 130
 131     PrepareCopy_Impl();
 132
 133     return m_xCopyInput->readBytes( aData, nBytesToRead );
 134 }
 135
 136
 137 sal_Int32 SAL_CALL OSeekableInputWrapper::readSomeBytes( uno::Sequence< sal_Int8 >& aData, sal_Int32 nMaxBytesToRead )
 138 {
 139     std::scoped_lock aGuard( m_aMutex );
 140
 141     if ( !m_xOriginalStream.is() )
 142         throw io::NotConnectedException();
 143
 144     PrepareCopy_Impl();
 145
 146     return m_xCopyInput->readSomeBytes( aData, nMaxBytesToRead );
 147 }
 148
 149 sal_Int32 OSeekableInputWrapper::readSomeBytes( sal_Int8* aData, sal_Int32 nMaxBytesToRead )
 150 {
 151     std::scoped_lock aGuard( m_aMutex );
 152
 153     if ( !m_xOriginalStream.is() )
 154         throw io::NotConnectedException();
 155
 156     PrepareCopy_Impl();
 157
 158     return m_pCopyByteReader->readSomeBytes( aData, nMaxBytesToRead );
 159 }
 160
 161
 162 void SAL_CALL OSeekableInputWrapper::skipBytes( sal_Int32 nBytesToSkip )
 163 {
 164     std::scoped_lock aGuard( m_aMutex );
 165
 166     if ( !m_xOriginalStream.is() )
 167         throw io::NotConnectedException();
 168
 169     PrepareCopy_Impl();
 170
 171     m_xCopyInput->skipBytes( nBytesToSkip );
 172 }
 173
 174
 175 sal_Int32 SAL_CALL OSeekableInputWrapper::available()
 176 {
 177     std::scoped_lock aGuard( m_aMutex );
 178
 179     if ( !m_xOriginalStream.is() )
 180         throw io::NotConnectedException();
 181
 182     PrepareCopy_Impl();
 183
 184     return m_xCopyInput->available();
 185 }
 186
 187
 188 void SAL_CALL OSeekableInputWrapper::closeInput()
 189 {
 190     std::scoped_lock aGuard( m_aMutex );
 191
 192     if ( !m_xOriginalStream.is() )
 193         throw io::NotConnectedException();
 194
 195     m_xOriginalStream->closeInput();
 196     m_xOriginalStream.clear();
 197
 198     if ( m_xCopyInput.is() )
 199     {
 200         m_xCopyInput->closeInput();
 201         m_xCopyInput.clear();
 202     }
 203
 204     m_xCopySeek.clear();
 205     m_pCopyByteReader = nullptr;
 206 }
 207
 208
 209 // XSeekable
 210
 211 void SAL_CALL OSeekableInputWrapper::seek( sal_Int64 location )
 212 {
 213     std::scoped_lock aGuard( m_aMutex );
 214
 215     if ( !m_xOriginalStream.is() )
 216         throw io::NotConnectedException();
 217
 218     PrepareCopy_Impl();
 219
 220     m_xCopySeek->seek( location );
 221 }
 222
 223
 224 sal_Int64 SAL_CALL OSeekableInputWrapper::getPosition()
 225 {
 226     std::scoped_lock aGuard( m_aMutex );
 227
 228     if ( !m_xOriginalStream.is() )
 229         throw io::NotConnectedException();
 230
 231     PrepareCopy_Impl();
 232
 233     return m_xCopySeek->getPosition();
 234 }
 235
 236
 237 sal_Int64 SAL_CALL OSeekableInputWrapper::getLength()
 238 {
 239     std::scoped_lock aGuard( m_aMutex );
 240
 241     if ( !m_xOriginalStream.is() )
 242         throw io::NotConnectedException();
 243
 244     PrepareCopy_Impl();
 245
 246     return m_xCopySeek->getLength();
 247 }
 248
 249 }   // namespace comphelper
 250
 251 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */