1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
|
/*************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright 2000, 2010 Oracle and/or its affiliates.
*
* OpenOffice.org - a multi-platform office productivity suite
*
* This file is part of OpenOffice.org.
*
* OpenOffice.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* only, as published by the Free Software Foundation.
*
* OpenOffice.org is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License version 3 for more details
* (a copy is included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU Lesser General Public License
* version 3 along with OpenOffice.org. If not, see
* <http://www.openoffice.org/license.html>
* for a copy of the LGPLv3 License.
*
************************************************************************/
#ifndef OOX_HELPER_BINARYINPUTSTREAM_HXX
#define OOX_HELPER_BINARYINPUTSTREAM_HXX
#include <boost/shared_ptr.hpp>
#include <com/sun/star/io/XInputStream.hpp>
#include "oox/helper/binarystreambase.hxx"
namespace oox {
class BinaryOutputStream;
// ============================================================================
/** Interface for binary input stream classes.
The binary data in the stream is assumed to be in little-endian format.
*/
class BinaryInputStream : public virtual BinaryStreamBase
{
public:
/** Derived classes implement reading nBytes bytes to the passed sequence.
@return Number of bytes really read. */
virtual sal_Int32 readData( StreamDataSequence& orData, sal_Int32 nBytes ) = 0;
/** Derived classes implement reading nBytes bytes to the (existing) buffer opMem.
@return Number of bytes really read. */
virtual sal_Int32 readMemory( void* opMem, sal_Int32 nBytes ) = 0;
/** Derived classes implement seeking the stream forward by the passed
number of bytes. This should work for non-seekable streams too. */
virtual void skip( sal_Int32 nBytes ) = 0;
/** Reads a value from the stream and converts it to platform byte order.
Supported types: SAL integers (8 to 64 bit), float, double. */
template< typename Type >
void readValue( Type& ornValue );
/** Reads a value from the stream and converts it to platform byte order.
Supported types: SAL integers (8 to 64 bit), float, double. */
template< typename Type >
inline Type readValue() { Type nValue; readValue( nValue ); return nValue; }
/** Stream operator for integral and floating-point types. */
template< typename Type >
inline BinaryInputStream& operator>>( Type& ornValue ) { readValue( ornValue ); return *this; }
inline sal_Int8 readInt8() { return readValue< sal_Int8 >(); }
inline sal_uInt8 readuInt8() { return readValue< sal_uInt8 >(); }
inline sal_Int16 readInt16() { return readValue< sal_Int16 >(); }
inline sal_uInt16 readuInt16() { return readValue< sal_uInt16 >(); }
inline sal_Int32 readInt32() { return readValue< sal_Int32 >(); }
inline sal_uInt32 readuInt32() { return readValue< sal_uInt32 >(); }
inline sal_Int64 readInt64() { return readValue< sal_Int64 >(); }
inline sal_uInt64 readuInt64() { return readValue< sal_uInt64 >(); }
inline float readFloat() { return readValue< float >(); }
inline double readDouble() { return readValue< double >(); }
/** Reads a NUL-terminated byte character array and returns the string. */
::rtl::OString readNulCharArray();
/** Reads a NUL-terminated byte character array and returns a Unicode string.
@param eTextEnc The text encoding used to create the Unicode string. */
::rtl::OUString readNulCharArrayUC( rtl_TextEncoding eTextEnc );
/** Reads a NUL-terminated Unicode character array and returns the string. */
::rtl::OUString readNulUnicodeArray();
/** Reads nChar byte characters and returns the string.
@param nChars Number of characters (bytes) to read from the stream.
@param bAllowNulChars
True = NUL characters are inserted into the imported string.
False = NUL characters are replaced by question marks (default). */
::rtl::OString readCharArray( sal_Int32 nChars, bool bAllowNulChars = false );
/** Reads nChar byte characters and returns a Unicode string.
@param nChars Number of characters (bytes) to read from the stream.
@param eTextEnc The text encoding used to create the Unicode string.
@param bAllowNulChars
True = NUL characters are inserted into the imported string.
False = NUL characters are replaced by question marks (default). */
::rtl::OUString readCharArrayUC( sal_Int32 nChars, rtl_TextEncoding eTextEnc, bool bAllowNulChars = false );
/** Reads nChars Unicode characters and returns the string.
@param nChars Number of 16-bit characters to read from the stream.
@param bAllowNulChars
True = NUL characters are inserted into the imported string.
False = NUL characters are replaced by question marks (default). */
::rtl::OUString readUnicodeArray( sal_Int32 nChars, bool bAllowNulChars = false );
/** Copies nBytes bytes from the current position to the passed output stream. */
void copyToStream( BinaryOutputStream& rOutStrm, sal_Int64 nBytes = SAL_MAX_INT64 );
private:
/** Used by the readValue() template functions to read built-in types.
@descr Derived classes may overwrite this default implementation which
simply calls readMemory() with something own. */
virtual void readAtom( void* opMem, sal_uInt8 nSize );
};
typedef ::boost::shared_ptr< BinaryInputStream > BinaryInputStreamRef;
// ----------------------------------------------------------------------------
template< typename Type >
void BinaryInputStream::readValue( Type& ornValue )
{
// can be instanciated for all types supported in class ByteOrderConverter
readAtom( &ornValue, static_cast< sal_Int32 >( sizeof( Type ) ) );
ByteOrderConverter::convertLittleEndian( ornValue );
}
// ============================================================================
/** Wraps a com.sun.star.io.XInputStream and provides convenient access functions.
The binary data in the stream is assumed to be in little-endian format.
*/
class BinaryXInputStream : public BinaryXSeekableStream, public BinaryInputStream
{
public:
/** Constructs the wrapper object for the passed input stream.
@param rxInStream The com.sun.star.io.XInputStream interface of the
input stream to be wrapped.
@param bAutoClose True = automatically close the wrapped input stream
on destruction of this wrapper.
*/
explicit BinaryXInputStream(
const ::com::sun::star::uno::Reference< ::com::sun::star::io::XInputStream >& rxInStrm,
bool bAutoClose );
virtual ~BinaryXInputStream();
/** Reads nBytes bytes to the passed sequence.
@return Number of bytes really read. */
virtual sal_Int32 readData( StreamDataSequence& orData, sal_Int32 nBytes );
/** Reads nBytes bytes to the (existing) buffer opMem.
@return Number of bytes really read. */
virtual sal_Int32 readMemory( void* opMem, sal_Int32 nBytes );
/** Seeks the stream forward by the passed number of bytes. This works for
non-seekable streams too. */
virtual void skip( sal_Int32 nBytes );
/** Stream operator for integral and floating-point types. */
template< typename Type >
inline BinaryXInputStream& operator>>( Type& ornValue ) { readValue( ornValue ); return *this; }
/** Returns the XInputStream interface of the wrapped input stream. */
inline ::com::sun::star::uno::Reference< ::com::sun::star::io::XInputStream >
getXInputStream() const { return mxInStrm; }
/** Closes the wrapped XInputStream. */
void close();
private:
StreamDataSequence maBuffer; /// Data buffer used in readMemory() function.
::com::sun::star::uno::Reference< ::com::sun::star::io::XInputStream >
mxInStrm; /// Reference to the input stream.
bool mbAutoClose; /// True = automatically close stream on destruction.
};
typedef ::boost::shared_ptr< BinaryXInputStream > BinaryXInputStreamRef;
// ============================================================================
/** Wraps a StreamDataSequence and provides convenient access functions.
The binary data in the stream is assumed to be in little-endian format.
*/
class SequenceInputStream : public SequenceSeekableStream, public BinaryInputStream
{
public:
/** Constructs the wrapper object for the passed data sequence.
@attention
The passed data sequence MUST live at least as long as this stream
wrapper. The data sequence MUST NOT be changed from outside as long
as this stream wrapper is used to read from it.
*/
explicit SequenceInputStream( const StreamDataSequence& rData );
/** Reads nBytes bytes to the passed sequence.
@return Number of bytes really read. */
virtual sal_Int32 readData( StreamDataSequence& orData, sal_Int32 nBytes );
/** Reads nBytes bytes to the (existing) buffer opMem.
@return Number of bytes really read. */
virtual sal_Int32 readMemory( void* opMem, sal_Int32 nBytes );
/** Seeks the stream forward by the passed number of bytes. This works for
non-seekable streams too. */
virtual void skip( sal_Int32 nBytes );
/** Stream operator for integral and floating-point types. */
template< typename Type >
inline SequenceInputStream& operator>>( Type& ornValue ) { readValue( ornValue ); return *this; }
};
typedef ::boost::shared_ptr< SequenceInputStream > SequenceInputStreamRef;
// ============================================================================
/** Wraps a BinaryInputStream and provides access to a specific part of the
stream data.
@descr
Provides access to the stream data block starting at the current
position of the stream, and with a specific length. If the wrapped
stream is seekable, this wrapper will treat the position the wrapped
has at construction time as position "0" (therefore the class name).
*/
class RelativeInputStream : public BinaryInputStream
{
public:
/** Constructs the wrapper object for the passed stream.
@attention
The passed input stream MUST live at least as long as this stream
wrapper. The stream MUST NOT be changed from outside as long as
this stream wrapper is used to read from it.
@param nLength
If specified, restricts the amount of data that can be read from
the passed input stream.
*/
explicit RelativeInputStream(
BinaryInputStream& rInStrm,
sal_Int64 nLength = SAL_MAX_INT64 );
/** Returns whether the wrapped stream is seekable. */
virtual bool isSeekable() const;
/** Returns the size of the data block in the wrapped stream offered by
this wrapper. */
virtual sal_Int64 getLength() const;
/** Returns the current relative stream position. */
virtual sal_Int64 tell() const;
/** Seeks the stream to the passed relative position, if the wrapped stream
is seekable. */
virtual void seek( sal_Int64 nPos );
/** Reads nBytes bytes to the passed sequence. Does not read out of the
data block whose size has been specified on construction.
@return Number of bytes really read. */
virtual sal_Int32 readData( StreamDataSequence& orData, sal_Int32 nBytes );
/** Reads nBytes bytes to the (existing) buffer opMem. Does not read out of
the data block whose size has been specified on construction.
@return Number of bytes really read. */
virtual sal_Int32 readMemory( void* opMem, sal_Int32 nBytes );
/** Seeks the stream forward by the passed number of bytes. This works for
non-seekable streams too. Does not seek out of the data block. */
virtual void skip( sal_Int32 nBytes );
/** Stream operator for integral and floating-point types. */
template< typename Type >
inline RelativeInputStream& operator>>( Type& ornValue ) { readValue( ornValue ); return *this; }
private:
BinaryInputStream& mrInStrm;
sal_Int64 mnStartPos;
sal_Int64 mnRelPos;
sal_Int64 mnLength;
};
typedef ::boost::shared_ptr< RelativeInputStream > RelativeInputStreamRef;
// ============================================================================
} // namespace oox
#endif
|