package/source/zippackage/wrapstreamforshare.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 <osl/diagnose.h>
  21
  22 #include "wrapstreamforshare.hxx"
  23
  24 using namespace ::com::sun::star;
  25
  26 #if OSL_DEBUG_LEVEL > 0
  27 #define THROW_WHERE SAL_WHERE
  28 #else
  29 #define THROW_WHERE ""
  30 #endif
  31
  32 WrapStreamForShare::WrapStreamForShare( const uno::Reference< io::XInputStream >& xInStream,
  33                                         const SotMutexHolderRef& rMutexRef )
  34 : m_rMutexRef( rMutexRef )
  35 , m_xInStream( xInStream )
  36 , m_nCurPos( 0 )
  37 {
  38     m_xSeekable = uno::Reference< io::XSeekable >( m_xInStream, uno::UNO_QUERY );
  39     if ( !m_rMutexRef.Is() || !m_xInStream.is() || !m_xSeekable.is() )
  40     {
  41         OSL_FAIL( "Wrong initialization of wrapping stream!\n" );
  42         throw uno::RuntimeException(THROW_WHERE );
  43     }
  44 }
  45
  46 WrapStreamForShare::~WrapStreamForShare()
  47 {
  48 }
  49
  50 // XInputStream
  51 sal_Int32 SAL_CALL WrapStreamForShare::readBytes( uno::Sequence< sal_Int8 >& aData, sal_Int32 nBytesToRead )
  52         throw ( io::NotConnectedException,
  53                 io::BufferSizeExceededException,
  54                 io::IOException,
  55                 uno::RuntimeException, std::exception )
  56 {
  57     if ( !m_xInStream.is() )
  58         throw io::IOException(THROW_WHERE );
  59
  60     m_xSeekable->seek( m_nCurPos );
  61
  62     sal_Int32 nRead = m_xInStream->readBytes( aData, nBytesToRead );
  63     m_nCurPos += nRead;
  64
  65     return nRead;
  66 }
  67
  68 sal_Int32 SAL_CALL WrapStreamForShare::readSomeBytes( uno::Sequence< sal_Int8 >& aData, sal_Int32 nMaxBytesToRead )
  69         throw ( io::NotConnectedException,
  70                 io::BufferSizeExceededException,
  71                 io::IOException,
  72                 uno::RuntimeException, std::exception )
  73 {
  74     if ( !m_xInStream.is() )
  75         throw io::IOException(THROW_WHERE );
  76
  77     m_xSeekable->seek( m_nCurPos );
  78
  79     sal_Int32 nRead = m_xInStream->readSomeBytes( aData, nMaxBytesToRead );
  80     m_nCurPos += nRead;
  81
  82     return nRead;
  83 }
  84
  85 void SAL_CALL WrapStreamForShare::skipBytes( sal_Int32 nBytesToSkip )
  86         throw ( io::NotConnectedException,
  87                 io::BufferSizeExceededException,
  88                 io::IOException,
  89                 uno::RuntimeException, std::exception )
  90 {
  91     ::osl::MutexGuard aGuard( m_rMutexRef->GetMutex() );
  92
  93     if ( !m_xInStream.is() )
  94         throw io::IOException(THROW_WHERE );
  95
  96     m_xSeekable->seek( m_nCurPos );
  97
  98     m_xInStream->skipBytes( nBytesToSkip );
  99     m_nCurPos = m_xSeekable->getPosition();
 100 }
 101
 102 sal_Int32 SAL_CALL WrapStreamForShare::available()
 103         throw ( io::NotConnectedException,
 104                 io::IOException,
 105                 uno::RuntimeException, std::exception )
 106 {
 107     ::osl::MutexGuard aGuard( m_rMutexRef->GetMutex() );
 108
 109     if ( !m_xInStream.is() )
 110         throw io::IOException(THROW_WHERE );
 111
 112     return m_xInStream->available();
 113 }
 114
 115 void SAL_CALL WrapStreamForShare::closeInput()
 116         throw ( io::NotConnectedException,
 117                 io::IOException,
 118                 uno::RuntimeException, std::exception )
 119 {
 120     ::osl::MutexGuard aGuard( m_rMutexRef->GetMutex() );
 121
 122     if ( !m_xInStream.is() )
 123         throw io::IOException(THROW_WHERE );
 124
 125     // the package is the owner so it will close the stream
 126     // m_xInStream->closeInput();
 127     m_xInStream = uno::Reference< io::XInputStream >();
 128     m_xSeekable = uno::Reference< io::XSeekable >();
 129 }
 130
 131 // XSeekable
 132 void SAL_CALL WrapStreamForShare::seek( sal_Int64 location )
 133         throw ( lang::IllegalArgumentException,
 134                 io::IOException,
 135                 uno::RuntimeException, std::exception )
 136 {
 137     ::osl::MutexGuard aGuard( m_rMutexRef->GetMutex() );
 138
 139     if ( !m_xInStream.is() )
 140         throw io::IOException(THROW_WHERE );
 141
 142     // let stream implementation do all the checking
 143     m_xSeekable->seek( location );
 144
 145     m_nCurPos = m_xSeekable->getPosition();
 146 }
 147
 148 sal_Int64 SAL_CALL WrapStreamForShare::getPosition()
 149         throw ( io::IOException,
 150                 uno::RuntimeException, std::exception)
 151 {
 152     ::osl::MutexGuard aGuard( m_rMutexRef->GetMutex() );
 153
 154     if ( !m_xInStream.is() )
 155         throw io::IOException(THROW_WHERE );
 156
 157     return m_nCurPos;
 158 }
 159
 160 sal_Int64 SAL_CALL WrapStreamForShare::getLength()
 161         throw ( io::IOException,
 162                 uno::RuntimeException, std::exception )
 163 {
 164     ::osl::MutexGuard aGuard( m_rMutexRef->GetMutex() );
 165
 166     if ( !m_xInStream.is() )
 167         throw io::IOException(THROW_WHERE );
 168
 169     return m_xSeekable->getLength();
 170 }
 171
 172 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */