binaryinputstream.hxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */
 
#ifndef INCLUDED_OOX_HELPER_BINARYINPUTSTREAM_HXX
#define INCLUDED_OOX_HELPER_BINARYINPUTSTREAM_HXX
 
#include <cstddef>
#include <memory>
#include <vector>
 
#include <com/sun/star/uno/Reference.hxx>
#include <oox/dllapi.h>
#include <oox/helper/binarystreambase.hxx>
#include <oox/helper/helper.hxx>
#include <rtl/string.hxx>
#include <rtl/textenc.h>
#include <rtl/ustring.hxx>
#include <sal/types.h>
 
namespace com::sun::star {
    namespace io { class XInputStream; }
}
 
namespace oox {
 
class BinaryOutputStream;
 
 
class OOX_DLLPUBLIC BinaryInputStream : public virtual BinaryStreamBase
{
public:
    virtual sal_Int32   readData( StreamDataSequence& orData, sal_Int32 nBytes, size_t nAtomSize = 1 ) = 0;
 
    virtual sal_Int32   readMemory( void* opMem, sal_Int32 nBytes, size_t nAtomSize = 1 ) = 0;
 
    virtual void        skip( sal_Int32 nBytes, size_t nAtomSize = 1 ) = 0;
 
    template< typename Type >
    [[nodiscard]]
    Type                 readValue();
 
    [[nodiscard]]
    sal_Int8             readInt8()   { return readValue<sal_Int8>(); }
    [[nodiscard]]
    sal_uInt8            readuInt8()  { return readValue<sal_uInt8>(); }
    [[nodiscard]]
    sal_Int16            readInt16()  { return readValue<sal_Int16>(); }
    [[nodiscard]]
    sal_uInt16           readuInt16() { return readValue<sal_uInt16>(); }
    [[nodiscard]]
    sal_Int32            readInt32()  { return readValue<sal_Int32>(); }
    [[nodiscard]]
    sal_uInt32           readuInt32() { return readValue<sal_uInt32>(); }
    [[nodiscard]]
    sal_Int64            readInt64()  { return readValue<sal_Int64>(); }
    [[nodiscard]]
    float                readFloat()  { return readValue<float>(); }
    [[nodiscard]]
    double               readDouble() { return readValue<double>(); }
    [[nodiscard]]
    unsigned char        readuChar()  { return readValue<unsigned char>(); }
 
    template< typename Type >
    sal_Int32           readArray( Type* opnArray, sal_Int32 nElemCount );
 
    template< typename Type >
    sal_Int32           readArray( ::std::vector< Type >& orVector, sal_Int32 nElemCount );
 
    OUString     readNulUnicodeArray();
 
    OString      readCharArray( sal_Int32 nChars );
 
    OUString     readCharArrayUC( sal_Int32 nChars, rtl_TextEncoding eTextEnc );
 
    OUString     readUnicodeArray( sal_Int32 nChars );
 
    OUString     readCompressedUnicodeArray( sal_Int32 nChars, bool bCompressed );
 
    void         copyToStream( BinaryOutputStream& rOutStrm );
 
protected:
    BinaryInputStream() : BinaryStreamBase( false ) {}
 
private:
    BinaryInputStream( BinaryInputStream const& ) = delete;
    BinaryInputStream& operator=( BinaryInputStream const& ) = delete;
};
 
typedef std::shared_ptr< BinaryInputStream > BinaryInputStreamRef;
 
 
template< typename Type >
Type BinaryInputStream::readValue()
{
    Type ornValue = Type();
    readMemory( &ornValue, static_cast< sal_Int32 >( sizeof( Type ) ), sizeof( Type ) );
    ByteOrderConverter::convertLittleEndian( ornValue );
    return ornValue;
}
 
template< typename Type >
sal_Int32 BinaryInputStream::readArray( Type* opnArray, sal_Int32 nElemCount )
{
    sal_Int32 nRet = 0;
    if( !mbEof )
    {
        sal_Int32 nReadSize = getLimitedValue< sal_Int32, sal_Int32 >( nElemCount, 0, SAL_MAX_INT32 / sizeof( Type ) ) * sizeof( Type );
        nRet = readMemory( opnArray, nReadSize, sizeof( Type ) ) / sizeof( Type );
        ByteOrderConverter::convertLittleEndianArray( opnArray, static_cast< size_t >( nRet ) );
    }
    return nRet;
}
 
template< typename Type >
sal_Int32 BinaryInputStream::readArray( ::std::vector< Type >& orVector, sal_Int32 nElemCount )
{
    orVector.resize( static_cast< size_t >( nElemCount ) );
    return orVector.empty() ? 0 : readArray(orVector.data(), nElemCount);
}
 
 
class OOX_DLLPUBLIC BinaryXInputStream final : public BinaryXSeekableStream, public BinaryInputStream
{
public:
    explicit            BinaryXInputStream(
                            const css::uno::Reference< css::io::XInputStream >& rxInStrm,
                            bool bAutoClose );
 
    virtual             ~BinaryXInputStream() override;
 
    virtual void        close() override;
 
    virtual sal_Int32   readData( StreamDataSequence& orData, sal_Int32 nBytes, size_t nAtomSize = 1 ) override;
 
    virtual sal_Int32   readMemory( void* opMem, sal_Int32 nBytes, size_t nAtomSize = 1 ) override;
 
    virtual void        skip( sal_Int32 nBytes, size_t nAtomSize = 1 ) override;
 
private:
    StreamDataSequence  maBuffer;       
    css::uno::Reference< css::io::XInputStream >
                        mxInStrm;       
    bool                mbAutoClose;    
};
 
 
class OOX_DLLPUBLIC SequenceInputStream final : public SequenceSeekableStream, public BinaryInputStream
{
public:
    explicit            SequenceInputStream( const StreamDataSequence& rData );
 
    virtual sal_Int32   readData( StreamDataSequence& orData, sal_Int32 nBytes, size_t nAtomSize = 1 ) override;
 
    virtual sal_Int32   readMemory( void* opMem, sal_Int32 nBytes, size_t nAtomSize = 1 ) override;
 
    virtual void        skip( sal_Int32 nBytes, size_t nAtomSize = 1 ) override;
 
private:
    sal_Int32    getMaxBytes( sal_Int32 nBytes ) const
                            { return getLimitedValue< sal_Int32, sal_Int32 >( nBytes, 0, mpData->getLength() - mnPos ); }
};
 
 
class RelativeInputStream final : public BinaryInputStream
{
public:
    explicit            RelativeInputStream(
                            BinaryInputStream& rInStrm,
                            sal_Int64 nSize );
 
    virtual sal_Int64   size() const override;
 
    virtual sal_Int64   tell() const override;
 
    virtual void        seek( sal_Int64 nPos ) override;
 
    virtual void        close() override;
 
    virtual sal_Int32   readData( StreamDataSequence& orData, sal_Int32 nBytes, size_t nAtomSize = 1 ) override;
 
    virtual sal_Int32   readMemory( void* opMem, sal_Int32 nBytes, size_t nAtomSize = 1 ) override;
 
    virtual void        skip( sal_Int32 nBytes, size_t nAtomSize = 1 ) override;
 
private:
    sal_Int32    getMaxBytes( sal_Int32 nBytes ) const
                            { return getLimitedValue< sal_Int32, sal_Int64 >( nBytes, 0, mnSize - mnRelPos ); }
 
private:
    BinaryInputStream*  mpInStrm;
    sal_Int64           mnStartPos;
    sal_Int64           mnRelPos;
    sal_Int64           mnSize;
};
 
 
} // namespace oox
 
#endif
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */