package/source/zipapi/ByteGrabber.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2000, 2010 Oracle and/or its affiliates.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * This file is part of OpenOffice.org.
  10  *
  11  * OpenOffice.org is free software: you can redistribute it and/or modify
  12  * it under the terms of the GNU Lesser General Public License version 3
  13  * only, as published by the Free Software Foundation.
  14  *
  15  * OpenOffice.org is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU Lesser General Public License version 3 for more details
  19  * (a copy is included in the LICENSE file that accompanied this code).
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * version 3 along with OpenOffice.org.  If not, see
  23  * <http://www.openoffice.org/license.html>
  24  * for a copy of the LGPLv3 License.
  25  *
  26  ************************************************************************/
  27
  28 // MARKER(update_precomp.py): autogen include statement, do not remove
  29 #include "precompiled_package.hxx"
  30 #include <ByteGrabber.hxx>
  31 #include <com/sun/star/io/XSeekable.hpp>
  32 #include <com/sun/star/io/XInputStream.hpp>
  33
  34 using namespace ::com::sun::star;
  35
  36 /** ByteGrabber implements the >> operators on an XOutputStream. This is
  37  *  potentially quite slow and may need to be optimised
  38  */
  39
  40 ByteGrabber::ByteGrabber(uno::Reference  < io::XInputStream > xIstream)
  41 : xStream(xIstream)
  42 , xSeek (xIstream, uno::UNO_QUERY )
  43 , aSequence ( 4 )
  44 {
  45     pSequence = aSequence.getArray();
  46 }
  47
  48 ByteGrabber::~ByteGrabber()
  49 {
  50 }
  51
  52 void ByteGrabber::setInputStream (uno::Reference < io::XInputStream > xNewStream)
  53 {
  54     ::osl::MutexGuard aGuard( m_aMutex );
  55     xStream = xNewStream;
  56     xSeek = uno::Reference < io::XSeekable > (xNewStream, uno::UNO_QUERY);
  57 }
  58
  59 // XInputStream chained
  60 sal_Int32 SAL_CALL ByteGrabber::readBytes( uno::Sequence< sal_Int8 >& aData,
  61                                         sal_Int32 nBytesToRead )
  62     throw(io::NotConnectedException, io::BufferSizeExceededException, io::IOException, uno::RuntimeException)
  63 {
  64     ::osl::MutexGuard aGuard( m_aMutex );
  65     return xStream->readBytes(aData, nBytesToRead );
  66 }
  67
  68 // XSeekable chained...
  69 sal_Int64 SAL_CALL ByteGrabber::seek( sal_Int64 location )
  70     throw(lang::IllegalArgumentException, io::IOException, uno::RuntimeException)
  71 {
  72     ::osl::MutexGuard aGuard( m_aMutex );
  73     if (xSeek.is() )
  74     {
  75         sal_Int64 nLen = xSeek->getLength();
  76         if ( location < 0 || location > nLen )
  77             throw lang::IllegalArgumentException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >(), 1 );
  78         if (location > nLen )
  79             location = nLen;
  80         xSeek->seek( location );
  81         return location;
  82     }
  83     else
  84         throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
  85 }
  86
  87 sal_Int64 SAL_CALL ByteGrabber::getPosition(  )
  88         throw(io::IOException, uno::RuntimeException)
  89 {
  90     ::osl::MutexGuard aGuard( m_aMutex );
  91     if (xSeek.is() )
  92         return xSeek->getPosition();
  93     else
  94         throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
  95 }
  96
  97 sal_Int64 SAL_CALL ByteGrabber::getLength(  )
  98         throw(io::IOException, uno::RuntimeException)
  99 {
 100     ::osl::MutexGuard aGuard( m_aMutex );
 101     if (xSeek.is() )
 102         return xSeek->getLength();
 103     else
 104         throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
 105 }
 106
 107 ByteGrabber& ByteGrabber::operator >> (sal_Int8& rInt8)
 108 {
 109     ::osl::MutexGuard aGuard( m_aMutex );
 110     if (xStream->readBytes(aSequence,1) != 1)
 111         rInt8 = 0;
 112     else
 113         rInt8 = aSequence[0] & 0xFF;
 114     return *this;
 115 }
 116
 117 ByteGrabber& ByteGrabber::operator >> (sal_Int16& rInt16)
 118 {
 119     ::osl::MutexGuard aGuard( m_aMutex );
 120     if (xStream->readBytes ( aSequence, 2) != 2)
 121         rInt16 = 0;
 122     else
 123     {
 124         pSequence = aSequence.getConstArray();
 125         rInt16 = static_cast <sal_Int16>
 126                ( (pSequence[0] & 0xFF)
 127               | (pSequence[1] & 0xFF) << 8);
 128     }
 129     return *this;
 130 }
 131
 132 ByteGrabber& ByteGrabber::operator >> (sal_Int32& rInt32)
 133 {
 134     ::osl::MutexGuard aGuard( m_aMutex );
 135
 136     if (xStream->readBytes(aSequence, 4) != 4)
 137         rInt32 = 0;
 138     else
 139     {
 140         pSequence = aSequence.getConstArray();
 141         rInt32 = static_cast < sal_Int32 >
 142                 ( (pSequence[0] & 0xFF)
 143               | ( pSequence[1] & 0xFF ) << 8
 144               | ( pSequence[2] & 0xFF ) << 16
 145               | ( pSequence[3] & 0xFF ) << 24 );
 146     }
 147     return *this;
 148 }
 149
 150 ByteGrabber& ByteGrabber::operator >> (sal_uInt8& rInt8)
 151 {
 152     ::osl::MutexGuard aGuard( m_aMutex );
 153
 154     if (xStream->readBytes(aSequence,1) != 1)
 155         rInt8 = 0;
 156     else
 157         rInt8 = static_cast < sal_uInt8 > (aSequence[0] & 0xFF );
 158     return *this;
 159 }
 160 ByteGrabber& ByteGrabber::operator >> (sal_uInt16& rInt16)
 161 {
 162     ::osl::MutexGuard aGuard( m_aMutex );
 163
 164     if (xStream->readBytes(aSequence, 2) != 2)
 165         rInt16 = 0;
 166     else
 167     {
 168         pSequence = aSequence.getConstArray();
 169         rInt16 = static_cast <sal_uInt16>
 170                ( (pSequence[0] & 0xFF)
 171               | (pSequence[1] & 0xFF) << 8);
 172     }
 173     return *this;
 174 }
 175 ByteGrabber& ByteGrabber::operator >> (sal_uInt32& ruInt32)
 176 {
 177     ::osl::MutexGuard aGuard( m_aMutex );
 178
 179     if (xStream->readBytes(aSequence, 4) != 4)
 180         ruInt32 = 0;
 181     else
 182     {
 183         pSequence = aSequence.getConstArray();
 184         ruInt32 = static_cast < sal_uInt32 >
 185                 ( (pSequence[0] & 0xFF)
 186               | ( pSequence[1] & 0xFF ) << 8
 187               | ( pSequence[2] & 0xFF ) << 16
 188               | ( pSequence[3] & 0xFF ) << 24 );
 189     }
 190     return *this;
 191 }