include/oox/helper/binaryoutputstream.hxx

   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 #ifndef INCLUDED_OOX_HELPER_BINARYOUTPUTSTREAM_HXX
  21 #define INCLUDED_OOX_HELPER_BINARYOUTPUTSTREAM_HXX
  22
  23 #include <cstddef>
  24 #include <memory>
  25
  26 #include <com/sun/star/uno/Reference.hxx>
  27 #include <oox/dllapi.h>
  28 #include <oox/helper/binarystreambase.hxx>
  29 #include <oox/helper/helper.hxx>
  30 #include <rtl/textenc.h>
  31 #include <rtl/ustring.hxx>
  32 #include <sal/types.h>
  33
  34 namespace com { namespace sun { namespace star {
  35     namespace io { class XOutputStream; }
  36 } } }
  37
  38 namespace oox {
  39
  40
  41 /** Interface for binary output stream classes.
  42
  43     The binary data in the stream is written in little-endian format.
  44  */
  45 class BinaryOutputStream : public virtual BinaryStreamBase
  46 {
  47 public:
  48     /** Derived classes implement writing the contents of the passed data
  49         sequence.
  50
  51         @param nAtomSize
  52             The size of the elements in the memory block, if available. Derived
  53             classes may be interested in this information.
  54      */
  55     virtual void        writeData( const StreamDataSequence& rData, size_t nAtomSize = 1 ) = 0;
  56
  57     /** Derived classes implement writing the contents of the (preallocated!)
  58         memory buffer pMem.
  59
  60         @param nAtomSize
  61             The size of the elements in the memory block, if available. Derived
  62             classes may be interested in this information.
  63      */
  64     virtual void        writeMemory( const void* pMem, sal_Int32 nBytes, size_t nAtomSize = 1 ) = 0;
  65
  66     template< typename Type >
  67     void writeArray( Type* opnArray, sal_Int32 nElemCount );
  68
  69     template< typename Type >
  70     void writeArray( const Type* opnArray, sal_Int32 nElemCount );
  71
  72     /** Writes a value to the stream and converts it to platform byte order.
  73         All data types supported by the ByteOrderConverter class can be used.
  74      */
  75     template< typename Type >
  76     void                  writeValue( Type nValue );
  77
  78     BinaryOutputStream&   WriteInt16(sal_Int16 x)   { writeValue(x); return *this; }
  79     BinaryOutputStream&   WriteUInt16(sal_uInt16 x) { writeValue(x); return *this; }
  80     BinaryOutputStream&   WriteInt32(sal_Int32 x)   { writeValue(x); return *this; }
  81     BinaryOutputStream&   WriteUInt32(sal_uInt32 x) { writeValue(x); return *this; }
  82     BinaryOutputStream&   WriteInt64(sal_Int64 x)   { writeValue(x); return *this; }
  83
  84     void writeCompressedUnicodeArray( const OUString& rString, bool bCompressed );
  85
  86     void writeCharArrayUC( const OUString& rString, rtl_TextEncoding eTextEnc );
  87
  88     void writeUnicodeArray( const OUString& rString );
  89
  90 protected:
  91     /** This dummy default c'tor will never call the c'tor of the virtual base
  92         class BinaryStreamBase as this class cannot be instantiated directly. */
  93 #ifdef _MSC_VER
  94 #pragma warning(push)
  95 #pragma warning( disable : 4702)
  96 #endif
  97     BinaryOutputStream() : BinaryStreamBase( false ) {}
  98 #ifdef _MSC_VER
  99 #pragma warning(pop)
 100 #endif
 101
 102 private:
 103     BinaryOutputStream( BinaryOutputStream const& ) = delete;
 104     BinaryOutputStream& operator=( BinaryOutputStream const& ) = delete;
 105 };
 106
 107 template< typename Type >
 108 void BinaryOutputStream::writeArray( Type* opnArray, sal_Int32 nElemCount )
 109 {
 110     sal_Int32 nWriteSize = getLimitedValue< sal_Int32, sal_Int32 >( nElemCount, 0, SAL_MAX_INT32 / sizeof( Type ) ) * sizeof( Type );
 111     ByteOrderConverter::convertLittleEndianArray( opnArray, static_cast< size_t >( nElemCount ) );
 112     writeMemory( opnArray, nWriteSize, sizeof( Type ) );
 113 }
 114
 115 template< typename Type >
 116 void BinaryOutputStream::writeArray( const Type* opnArray, sal_Int32 nElemCount )
 117 {
 118     std::unique_ptr<Type[]> xArray(new Type[nElemCount]);
 119     std::uninitialized_copy(opnArray, opnArray + nElemCount, xArray.get());
 120     writeArray(xArray.get(), nElemCount);
 121 }
 122
 123 template< typename Type >
 124 void BinaryOutputStream::writeValue( Type nValue )
 125 {
 126     ByteOrderConverter::convertLittleEndian( nValue );
 127     writeMemory( &nValue, static_cast< sal_Int32 >( sizeof( Type ) ), sizeof( Type ) );
 128 }
 129
 130
 131 /** Wraps a UNO output stream and provides convenient access functions.
 132
 133     The binary data in the stream is written in little-endian format.
 134  */
 135 class BinaryXOutputStream : public BinaryXSeekableStream, public BinaryOutputStream
 136 {
 137 public:
 138     /** Constructs the wrapper object for the passed output stream.
 139
 140         @param rxOutStream
 141             The com.sun.star.io.XOutputStream interface of the output stream to
 142             be wrapped.
 143
 144         @param bAutoClose
 145             True = automatically close the wrapped output stream on destruction
 146             of this wrapper or when close() is called.
 147      */
 148     explicit            BinaryXOutputStream(
 149                             const css::uno::Reference< css::io::XOutputStream >& rxOutStrm,
 150                             bool bAutoClose );
 151
 152     virtual             ~BinaryXOutputStream() override;
 153
 154     /** Flushes and closes the output stream. Does also close the wrapped UNO
 155         output stream if bAutoClose has been set to true in the constructor. */
 156     void                close() override;
 157
 158     /** Writes the passed data sequence. */
 159     virtual void        writeData( const StreamDataSequence& rData, size_t nAtomSize = 1 ) override;
 160
 161     /** Write nBytes bytes from the (preallocated!) buffer pMem. */
 162     virtual void        writeMemory( const void* pMem, sal_Int32 nBytes, size_t nAtomSize = 1 ) override;
 163
 164 private:
 165     StreamDataSequence  maBuffer;       ///< Data buffer used in writeMemory() function.
 166     css::uno::Reference< css::io::XOutputStream >
 167                         mxOutStrm;      ///< Reference to the output stream.
 168     bool                mbAutoClose;    ///< True = automatically close stream on destruction.
 169 };
 170
 171
 172 /** Wraps a StreamDataSequence and provides convenient access functions.
 173
 174     The binary data in the stream is written in little-endian format. After
 175     construction, the stream points to the beginning of the passed data
 176     sequence. The data sequence is expanded automatically while writing to it.
 177  */
 178 class OOX_DLLPUBLIC SequenceOutputStream : public SequenceSeekableStream, public BinaryOutputStream
 179 {
 180 public:
 181     /** Constructs the wrapper object for the passed data sequence.
 182
 183         @attention
 184             The passed data sequence MUST live at least as long as this stream
 185             wrapper. The data sequence MUST NOT be changed from outside as long
 186             as this stream wrapper is used to write to it.
 187      */
 188     explicit            SequenceOutputStream( StreamDataSequence& rData );
 189
 190     /** Writes the passed data sequence. */
 191     virtual void        writeData( const StreamDataSequence& rData, size_t nAtomSize = 1 ) override;
 192
 193     /** Write nBytes bytes from the (preallocated!) buffer pMem. */
 194     virtual void        writeMemory( const void* pMem, sal_Int32 nBytes, size_t nAtomSize = 1 ) override;
 195 };
 196
 197
 198 } // namespace oox
 199
 200 #endif
 201
 202 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */