xmlhelp/source/cxxhelp/provider/bufferedinputstream.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: bufferedinputstream.cxx,v $
  10  * $Revision: 1.5 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31
  32 // MARKER(update_precomp.py): autogen include statement, do not remove
  33 #include "precompiled_xmlhelp.hxx"
  34 #include <rtl/memory.h>
  35 #include "bufferedinputstream.hxx"
  36
  37
  38 using namespace cppu;
  39 using namespace com::sun::star::uno;
  40 using namespace com::sun::star::lang;
  41 using namespace com::sun::star::io;
  42 using namespace chelp;
  43
  44
  45 Reference<XInputStream> chelp::turnToSeekable(const Reference<XInputStream>& xInputStream)
  46 {
  47     if( ! xInputStream.is() )
  48         return xInputStream;
  49
  50     Reference<XSeekable> xSeekable(xInputStream,UNO_QUERY);
  51
  52     if( xSeekable.is() )
  53         return xInputStream;
  54
  55     return new BufferedInputStream(xInputStream);
  56 }
  57
  58
  59
  60 BufferedInputStream::BufferedInputStream(const Reference<XInputStream>& xInputStream)
  61     : m_nBufferLocation(0),
  62       m_nBufferSize(0),
  63       m_pBuffer(new sal_Int8[1]) // Initialize with one to avoid gcc compiler warnings
  64 {
  65     try
  66     {
  67         sal_Int32 num;
  68         sal_Int8  *tmp;
  69         Sequence< sal_Int8 > aData(4096);
  70         do{
  71             num = xInputStream->readBytes(aData,4096);
  72             if( num > 0 )
  73             {
  74                 tmp = m_pBuffer;
  75                 m_pBuffer = new sal_Int8[m_nBufferSize+num];
  76                 rtl_copyMemory((void *)(m_pBuffer),
  77                                (void *)(tmp),
  78                                sal_uInt32(m_nBufferSize));
  79                 rtl_copyMemory((void *)(m_pBuffer+m_nBufferSize),
  80                                (void *)(aData.getArray()),
  81                                sal_uInt32(num));
  82                 m_nBufferSize += num;
  83                 delete[] tmp;
  84             }
  85         } while( num == 4096 );
  86     }
  87     catch( const NotConnectedException&)
  88     {
  89     }
  90     catch( const BufferSizeExceededException&)
  91     {
  92     }
  93     catch( const IOException&)
  94     {
  95     }
  96     catch( const RuntimeException&)
  97     {
  98     }
  99     xInputStream->closeInput();
 100 }
 101
 102
 103 BufferedInputStream::~BufferedInputStream()
 104 {
 105     delete[] m_pBuffer;
 106 }
 107
 108
 109 Any SAL_CALL BufferedInputStream::queryInterface( const Type& rType ) throw( RuntimeException )
 110 {
 111     Any aRet = ::cppu::queryInterface( rType,
 112                                        SAL_STATIC_CAST( XInputStream*,this ),
 113                                        SAL_STATIC_CAST( XSeekable*,this ) );
 114
 115     return aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType );
 116 }
 117
 118
 119 void SAL_CALL BufferedInputStream::acquire( void ) throw()
 120 {
 121     OWeakObject::acquire();
 122 }
 123
 124
 125 void SAL_CALL BufferedInputStream::release( void ) throw()
 126 {
 127     OWeakObject::release();
 128 }
 129
 130
 131
 132 sal_Int32 SAL_CALL BufferedInputStream::readBytes( Sequence< sal_Int8 >& aData,sal_Int32 nBytesToRead )
 133     throw( NotConnectedException,
 134            BufferSizeExceededException,
 135            IOException,
 136            RuntimeException)
 137 {
 138     osl::MutexGuard aGuard( m_aMutex );
 139
 140     if( 0 > nBytesToRead )
 141         throw BufferSizeExceededException();
 142
 143     if( m_nBufferLocation + nBytesToRead > m_nBufferSize )
 144         nBytesToRead = m_nBufferSize - m_nBufferLocation;
 145
 146     if( aData.getLength() < nBytesToRead )
 147         aData.realloc(nBytesToRead);
 148
 149     rtl_copyMemory((void*)(aData.getArray()),
 150                    (void*)(m_pBuffer+m_nBufferLocation),
 151                    nBytesToRead);
 152
 153     return nBytesToRead;
 154 }
 155
 156
 157 sal_Int32 SAL_CALL BufferedInputStream::readSomeBytes(
 158     Sequence< sal_Int8 >& aData,sal_Int32 nMaxBytesToRead )
 159     throw( NotConnectedException,
 160            BufferSizeExceededException,
 161            IOException,
 162            RuntimeException)
 163 {
 164     return readBytes(aData,nMaxBytesToRead);
 165 }
 166
 167
 168
 169 void SAL_CALL BufferedInputStream::skipBytes( sal_Int32 nBytesToSkip )
 170     throw( NotConnectedException,
 171            BufferSizeExceededException,
 172            IOException,
 173            RuntimeException )
 174 {
 175     try
 176     {
 177         seek(m_nBufferLocation+nBytesToSkip);
 178     }
 179     catch( const IllegalArgumentException& )
 180     {
 181         throw BufferSizeExceededException();
 182     }
 183 }
 184
 185
 186
 187 sal_Int32 SAL_CALL BufferedInputStream::available( void )
 188     throw( NotConnectedException,
 189            IOException,
 190            RuntimeException )
 191 {
 192     osl::MutexGuard aGuard( m_aMutex );
 193     return  m_nBufferSize-m_nBufferLocation;
 194 }
 195
 196
 197
 198 void SAL_CALL BufferedInputStream::closeInput( void )
 199     throw( NotConnectedException,
 200            IOException,
 201            RuntimeException )
 202 {
 203 }
 204
 205
 206 void SAL_CALL BufferedInputStream::seek( sal_Int64 location )
 207     throw( IllegalArgumentException,
 208            IOException,
 209            RuntimeException )
 210 {
 211     if( 0 <= location && location < m_nBufferSize )
 212     {
 213         osl::MutexGuard aGuard( m_aMutex );
 214         m_nBufferLocation = sal::static_int_cast<sal_Int32>( location );
 215     }
 216     else
 217         throw IllegalArgumentException();
 218 }
 219
 220
 221
 222 sal_Int64 SAL_CALL BufferedInputStream::getPosition( void )
 223     throw( IOException,
 224            RuntimeException )
 225 {
 226     osl::MutexGuard aGuard( m_aMutex );
 227     return m_nBufferLocation;
 228 }
 229
 230
 231
 232 sal_Int64 SAL_CALL BufferedInputStream::getLength( void ) throw( IOException,RuntimeException )
 233 {
 234     osl::MutexGuard aGuard( m_aMutex );
 235     return m_nBufferSize;
 236 }