1*b1cdbd2cSJim Jagielski /**************************************************************
2*b1cdbd2cSJim Jagielski *
3*b1cdbd2cSJim Jagielski * Licensed to the Apache Software Foundation (ASF) under one
4*b1cdbd2cSJim Jagielski * or more contributor license agreements. See the NOTICE file
5*b1cdbd2cSJim Jagielski * distributed with this work for additional information
6*b1cdbd2cSJim Jagielski * regarding copyright ownership. The ASF licenses this file
7*b1cdbd2cSJim Jagielski * to you under the Apache License, Version 2.0 (the
8*b1cdbd2cSJim Jagielski * "License"); you may not use this file except in compliance
9*b1cdbd2cSJim Jagielski * with the License. You may obtain a copy of the License at
10*b1cdbd2cSJim Jagielski *
11*b1cdbd2cSJim Jagielski * http://www.apache.org/licenses/LICENSE-2.0
12*b1cdbd2cSJim Jagielski *
13*b1cdbd2cSJim Jagielski * Unless required by applicable law or agreed to in writing,
14*b1cdbd2cSJim Jagielski * software distributed under the License is distributed on an
15*b1cdbd2cSJim Jagielski * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16*b1cdbd2cSJim Jagielski * KIND, either express or implied. See the License for the
17*b1cdbd2cSJim Jagielski * specific language governing permissions and limitations
18*b1cdbd2cSJim Jagielski * under the License.
19*b1cdbd2cSJim Jagielski *
20*b1cdbd2cSJim Jagielski *************************************************************/
21*b1cdbd2cSJim Jagielski
22*b1cdbd2cSJim Jagielski
23*b1cdbd2cSJim Jagielski #ifndef _STREAM_HXX
24*b1cdbd2cSJim Jagielski #define _STREAM_HXX
25*b1cdbd2cSJim Jagielski
26*b1cdbd2cSJim Jagielski #include "tools/toolsdllapi.h"
27*b1cdbd2cSJim Jagielski #include <tools/solar.h>
28*b1cdbd2cSJim Jagielski #include <tools/string.hxx>
29*b1cdbd2cSJim Jagielski #ifndef _EINF_HXX
30*b1cdbd2cSJim Jagielski #include <tools/errinf.hxx>
31*b1cdbd2cSJim Jagielski #endif
32*b1cdbd2cSJim Jagielski #include <tools/ref.hxx>
33*b1cdbd2cSJim Jagielski #include <tools/rtti.hxx>
34*b1cdbd2cSJim Jagielski
35*b1cdbd2cSJim Jagielski class FileCopier;
36*b1cdbd2cSJim Jagielski class StreamData;
37*b1cdbd2cSJim Jagielski
38*b1cdbd2cSJim Jagielski // ------------------------
39*b1cdbd2cSJim Jagielski // - FileFormat-Functions -
40*b1cdbd2cSJim Jagielski // ------------------------
41*b1cdbd2cSJim Jagielski
GetStoreCharSet(rtl_TextEncoding eEncoding)42*b1cdbd2cSJim Jagielski inline rtl_TextEncoding GetStoreCharSet( rtl_TextEncoding eEncoding )
43*b1cdbd2cSJim Jagielski {
44*b1cdbd2cSJim Jagielski if ( eEncoding == RTL_TEXTENCODING_ISO_8859_1 )
45*b1cdbd2cSJim Jagielski return RTL_TEXTENCODING_MS_1252;
46*b1cdbd2cSJim Jagielski else
47*b1cdbd2cSJim Jagielski return eEncoding;
48*b1cdbd2cSJim Jagielski }
49*b1cdbd2cSJim Jagielski
50*b1cdbd2cSJim Jagielski // ---------------
51*b1cdbd2cSJim Jagielski // - StreamTypes -
52*b1cdbd2cSJim Jagielski // ---------------
53*b1cdbd2cSJim Jagielski
54*b1cdbd2cSJim Jagielski typedef sal_uInt16 StreamMode;
55*b1cdbd2cSJim Jagielski
56*b1cdbd2cSJim Jagielski // read, write, create,... options
57*b1cdbd2cSJim Jagielski #define STREAM_READ 0x0001 // allow read accesses
58*b1cdbd2cSJim Jagielski #define STREAM_WRITE 0x0002 // allow write accesses
59*b1cdbd2cSJim Jagielski // file i/o
60*b1cdbd2cSJim Jagielski #define STREAM_NOCREATE 0x0004 // 1 == Dont create file
61*b1cdbd2cSJim Jagielski #define STREAM_TRUNC 0x0008 // Truncate _existing_ file to zero length
62*b1cdbd2cSJim Jagielski #define STREAM_COPY_ON_SYMLINK 0x0010 // copy-on-write for symlinks (UNX)
63*b1cdbd2cSJim Jagielski
64*b1cdbd2cSJim Jagielski #define STREAM_READWRITEBITS (STREAM_READ | STREAM_WRITE | \
65*b1cdbd2cSJim Jagielski STREAM_NOCREATE | STREAM_TRUNC)
66*b1cdbd2cSJim Jagielski
67*b1cdbd2cSJim Jagielski // sharing options
68*b1cdbd2cSJim Jagielski #define STREAM_SHARE_DENYNONE 0x0100
69*b1cdbd2cSJim Jagielski #define STREAM_SHARE_DENYREAD 0x0200 // overrides denynone
70*b1cdbd2cSJim Jagielski #define STREAM_SHARE_DENYWRITE 0x0400 // overrides denynone
71*b1cdbd2cSJim Jagielski #define STREAM_SHARE_DENYALL 0x0800 // overrides denyread,write,none
72*b1cdbd2cSJim Jagielski
73*b1cdbd2cSJim Jagielski #define STREAM_SHAREBITS (STREAM_SHARE_DENYNONE | STREAM_SHARE_DENYREAD |\
74*b1cdbd2cSJim Jagielski STREAM_SHARE_DENYWRITE | STREAM_SHARE_DENYALL)
75*b1cdbd2cSJim Jagielski
76*b1cdbd2cSJim Jagielski #define STREAM_READWRITE (STREAM_READ | STREAM_WRITE)
77*b1cdbd2cSJim Jagielski #define STREAM_SHARE_DENYREADWRITE (STREAM_SHARE_DENYREAD | STREAM_SHARE_DENYWRITE)
78*b1cdbd2cSJim Jagielski
79*b1cdbd2cSJim Jagielski #define STREAM_STD_READ (STREAM_READ | STREAM_SHARE_DENYNONE | STREAM_NOCREATE)
80*b1cdbd2cSJim Jagielski #define STREAM_STD_WRITE (STREAM_WRITE | STREAM_SHARE_DENYALL)
81*b1cdbd2cSJim Jagielski #define STREAM_STD_READWRITE (STREAM_READWRITE | STREAM_SHARE_DENYALL)
82*b1cdbd2cSJim Jagielski
83*b1cdbd2cSJim Jagielski #define STREAM_SEEK_TO_BEGIN 0L
84*b1cdbd2cSJim Jagielski #define STREAM_SEEK_TO_END ULONG_MAX
85*b1cdbd2cSJim Jagielski
86*b1cdbd2cSJim Jagielski #define NUMBERFORMAT_INT_BIGENDIAN (sal_uInt16)0x0000
87*b1cdbd2cSJim Jagielski #define NUMBERFORMAT_INT_LITTLEENDIAN (sal_uInt16)0xFFFF
88*b1cdbd2cSJim Jagielski
89*b1cdbd2cSJim Jagielski #define COMPRESSMODE_FULL (sal_uInt16)0xFFFF
90*b1cdbd2cSJim Jagielski #define COMPRESSMODE_NONE (sal_uInt16)0x0000
91*b1cdbd2cSJim Jagielski #define COMPRESSMODE_ZBITMAP (sal_uInt16)0x0001
92*b1cdbd2cSJim Jagielski #define COMPRESSMODE_NATIVE (sal_uInt16)0x0010
93*b1cdbd2cSJim Jagielski
94*b1cdbd2cSJim Jagielski #define JUSTIFY_RIGHT 0x00
95*b1cdbd2cSJim Jagielski #define JUSTIFY_LEFT 0x01
96*b1cdbd2cSJim Jagielski
97*b1cdbd2cSJim Jagielski #define STREAM_IO_DONTKNOW 0
98*b1cdbd2cSJim Jagielski #define STREAM_IO_READ 1
99*b1cdbd2cSJim Jagielski #define STREAM_IO_WRITE 2
100*b1cdbd2cSJim Jagielski
101*b1cdbd2cSJim Jagielski #define ID_STREAM 1
102*b1cdbd2cSJim Jagielski #define ID_FILESTREAM 2
103*b1cdbd2cSJim Jagielski #define ID_MEMORYSTREAM 3
104*b1cdbd2cSJim Jagielski #define ID_SHAREDMEMORYSTREAM 4
105*b1cdbd2cSJim Jagielski #define ID_STORAGESTREAM 5
106*b1cdbd2cSJim Jagielski #define ID_PERSISTSTREAM 6
107*b1cdbd2cSJim Jagielski
108*b1cdbd2cSJim Jagielski class SvStream;
109*b1cdbd2cSJim Jagielski typedef SvStream& (*SvStrPtr)( SvStream& );
110*b1cdbd2cSJim Jagielski
111*b1cdbd2cSJim Jagielski // forward declaration with internal linkage
112*b1cdbd2cSJim Jagielski inline SvStream& operator<<( SvStream& rStr, SvStrPtr f );
113*b1cdbd2cSJim Jagielski
114*b1cdbd2cSJim Jagielski // ---------------
115*b1cdbd2cSJim Jagielski // - SvLockBytes -
116*b1cdbd2cSJim Jagielski // ---------------
117*b1cdbd2cSJim Jagielski
118*b1cdbd2cSJim Jagielski enum LockType {};
119*b1cdbd2cSJim Jagielski
120*b1cdbd2cSJim Jagielski struct SvLockBytesStat
121*b1cdbd2cSJim Jagielski {
122*b1cdbd2cSJim Jagielski sal_Size nSize;
123*b1cdbd2cSJim Jagielski
SvLockBytesStatSvLockBytesStat124*b1cdbd2cSJim Jagielski SvLockBytesStat(): nSize(0) {}
125*b1cdbd2cSJim Jagielski };
126*b1cdbd2cSJim Jagielski
127*b1cdbd2cSJim Jagielski enum SvLockBytesStatFlag { SVSTATFLAG_DEFAULT };
128*b1cdbd2cSJim Jagielski
129*b1cdbd2cSJim Jagielski class TOOLS_DLLPUBLIC SvLockBytes: public virtual SvRefBase
130*b1cdbd2cSJim Jagielski {
131*b1cdbd2cSJim Jagielski SvStream * m_pStream;
132*b1cdbd2cSJim Jagielski sal_Bool m_bOwner;
133*b1cdbd2cSJim Jagielski sal_Bool m_bSync;
134*b1cdbd2cSJim Jagielski
135*b1cdbd2cSJim Jagielski protected:
136*b1cdbd2cSJim Jagielski void close();
137*b1cdbd2cSJim Jagielski
138*b1cdbd2cSJim Jagielski public:
139*b1cdbd2cSJim Jagielski TYPEINFO();
140*b1cdbd2cSJim Jagielski
SvLockBytes()141*b1cdbd2cSJim Jagielski SvLockBytes(): m_pStream(0), m_bOwner(sal_False), m_bSync(sal_False) {}
142*b1cdbd2cSJim Jagielski
SvLockBytes(SvStream * pTheStream,sal_Bool bTheOwner=sal_False)143*b1cdbd2cSJim Jagielski SvLockBytes(SvStream * pTheStream, sal_Bool bTheOwner = sal_False):
144*b1cdbd2cSJim Jagielski m_pStream(pTheStream), m_bOwner(bTheOwner), m_bSync(sal_False) {}
145*b1cdbd2cSJim Jagielski
~SvLockBytes()146*b1cdbd2cSJim Jagielski virtual ~SvLockBytes() { close(); }
147*b1cdbd2cSJim Jagielski
GetStream() const148*b1cdbd2cSJim Jagielski virtual const SvStream * GetStream() const { return m_pStream; }
149*b1cdbd2cSJim Jagielski
SetSynchronMode(sal_Bool bTheSync=sal_True)150*b1cdbd2cSJim Jagielski virtual void SetSynchronMode(sal_Bool bTheSync = sal_True) { m_bSync = bTheSync; }
151*b1cdbd2cSJim Jagielski
IsSynchronMode() const152*b1cdbd2cSJim Jagielski virtual sal_Bool IsSynchronMode() const { return m_bSync; }
153*b1cdbd2cSJim Jagielski
154*b1cdbd2cSJim Jagielski virtual ErrCode ReadAt(sal_Size nPos, void * pBuffer, sal_Size nCount,
155*b1cdbd2cSJim Jagielski sal_Size * pRead) const;
156*b1cdbd2cSJim Jagielski
157*b1cdbd2cSJim Jagielski virtual ErrCode WriteAt(sal_Size nPos, const void * pBuffer, sal_Size nCount,
158*b1cdbd2cSJim Jagielski sal_Size * pWritten);
159*b1cdbd2cSJim Jagielski
160*b1cdbd2cSJim Jagielski virtual ErrCode Flush() const;
161*b1cdbd2cSJim Jagielski
162*b1cdbd2cSJim Jagielski virtual ErrCode SetSize(sal_Size nSize);
163*b1cdbd2cSJim Jagielski
164*b1cdbd2cSJim Jagielski virtual ErrCode LockRegion(sal_Size, sal_Size, LockType);
165*b1cdbd2cSJim Jagielski
166*b1cdbd2cSJim Jagielski virtual ErrCode UnlockRegion(sal_Size, sal_Size, LockType);
167*b1cdbd2cSJim Jagielski
168*b1cdbd2cSJim Jagielski virtual ErrCode Stat(SvLockBytesStat * pStat, SvLockBytesStatFlag) const;
169*b1cdbd2cSJim Jagielski };
170*b1cdbd2cSJim Jagielski
171*b1cdbd2cSJim Jagielski SV_DECL_IMPL_REF(SvLockBytes);
172*b1cdbd2cSJim Jagielski
173*b1cdbd2cSJim Jagielski // -------------------
174*b1cdbd2cSJim Jagielski // - SvOpenLockBytes -
175*b1cdbd2cSJim Jagielski // -------------------
176*b1cdbd2cSJim Jagielski
177*b1cdbd2cSJim Jagielski class TOOLS_DLLPUBLIC SvOpenLockBytes: public SvLockBytes
178*b1cdbd2cSJim Jagielski {
179*b1cdbd2cSJim Jagielski public:
180*b1cdbd2cSJim Jagielski TYPEINFO();
181*b1cdbd2cSJim Jagielski
SvOpenLockBytes()182*b1cdbd2cSJim Jagielski SvOpenLockBytes(): SvLockBytes(0, sal_False) {}
183*b1cdbd2cSJim Jagielski
SvOpenLockBytes(SvStream * pStream,sal_Bool bOwner)184*b1cdbd2cSJim Jagielski SvOpenLockBytes(SvStream * pStream, sal_Bool bOwner):
185*b1cdbd2cSJim Jagielski SvLockBytes(pStream, bOwner) {}
186*b1cdbd2cSJim Jagielski
187*b1cdbd2cSJim Jagielski virtual ErrCode FillAppend(const void * pBuffer, sal_Size nCount,
188*b1cdbd2cSJim Jagielski sal_Size * pWritten) = 0;
189*b1cdbd2cSJim Jagielski
190*b1cdbd2cSJim Jagielski virtual sal_Size Tell() const = 0;
191*b1cdbd2cSJim Jagielski
192*b1cdbd2cSJim Jagielski virtual sal_Size Seek(sal_Size nPos) = 0;
193*b1cdbd2cSJim Jagielski
194*b1cdbd2cSJim Jagielski virtual void Terminate() = 0;
195*b1cdbd2cSJim Jagielski };
196*b1cdbd2cSJim Jagielski
197*b1cdbd2cSJim Jagielski SV_DECL_IMPL_REF(SvOpenLockBytes);
198*b1cdbd2cSJim Jagielski
199*b1cdbd2cSJim Jagielski // --------------------
200*b1cdbd2cSJim Jagielski // - SvAsyncLockBytes -
201*b1cdbd2cSJim Jagielski // --------------------
202*b1cdbd2cSJim Jagielski
203*b1cdbd2cSJim Jagielski class SvAsyncLockBytes: public SvOpenLockBytes
204*b1cdbd2cSJim Jagielski {
205*b1cdbd2cSJim Jagielski sal_Size m_nSize;
206*b1cdbd2cSJim Jagielski sal_Bool m_bTerminated;
207*b1cdbd2cSJim Jagielski
208*b1cdbd2cSJim Jagielski public:
209*b1cdbd2cSJim Jagielski TYPEINFO();
210*b1cdbd2cSJim Jagielski
SvAsyncLockBytes(SvStream * pStream,sal_Bool bOwner)211*b1cdbd2cSJim Jagielski SvAsyncLockBytes(SvStream * pStream, sal_Bool bOwner):
212*b1cdbd2cSJim Jagielski SvOpenLockBytes(pStream, bOwner), m_nSize(0), m_bTerminated(sal_False) {}
213*b1cdbd2cSJim Jagielski
214*b1cdbd2cSJim Jagielski virtual ErrCode ReadAt(sal_Size nPos, void * pBuffer, sal_Size nCount,
215*b1cdbd2cSJim Jagielski sal_Size * pRead) const;
216*b1cdbd2cSJim Jagielski
217*b1cdbd2cSJim Jagielski virtual ErrCode WriteAt(sal_Size nPos, const void * pBuffer, sal_Size nCount,
218*b1cdbd2cSJim Jagielski sal_Size * pWritten);
219*b1cdbd2cSJim Jagielski
220*b1cdbd2cSJim Jagielski virtual ErrCode FillAppend(const void * pBuffer, sal_Size nCount,
221*b1cdbd2cSJim Jagielski sal_Size * pWritten);
222*b1cdbd2cSJim Jagielski
Tell() const223*b1cdbd2cSJim Jagielski virtual sal_Size Tell() const { return m_nSize; }
224*b1cdbd2cSJim Jagielski
225*b1cdbd2cSJim Jagielski virtual sal_Size Seek(sal_Size nPos);
226*b1cdbd2cSJim Jagielski
Terminate()227*b1cdbd2cSJim Jagielski virtual void Terminate() { m_bTerminated = sal_True; }
228*b1cdbd2cSJim Jagielski };
229*b1cdbd2cSJim Jagielski
230*b1cdbd2cSJim Jagielski SV_DECL_IMPL_REF(SvAsyncLockBytes);
231*b1cdbd2cSJim Jagielski
232*b1cdbd2cSJim Jagielski // ----------
233*b1cdbd2cSJim Jagielski // - Stream -
234*b1cdbd2cSJim Jagielski // ----------
235*b1cdbd2cSJim Jagielski
236*b1cdbd2cSJim Jagielski class TOOLS_DLLPUBLIC SvStream
237*b1cdbd2cSJim Jagielski {
238*b1cdbd2cSJim Jagielski private:
239*b1cdbd2cSJim Jagielski // LockBytes Interface
240*b1cdbd2cSJim Jagielski void* pImp; // unused
241*b1cdbd2cSJim Jagielski SvLockBytesRef xLockBytes; // Default Implmentierung
242*b1cdbd2cSJim Jagielski sal_Size nActPos; //
243*b1cdbd2cSJim Jagielski
244*b1cdbd2cSJim Jagielski // Puffer-Verwaltung
245*b1cdbd2cSJim Jagielski sal_uInt8* pRWBuf; // Zeigt auf Read/Write-Puffer
246*b1cdbd2cSJim Jagielski sal_uInt8* pBufPos; // pRWBuf + nBufActualPos
247*b1cdbd2cSJim Jagielski sal_uInt16 nBufSize; // Allozierte Groesse des Puffers
248*b1cdbd2cSJim Jagielski sal_uInt16 nBufActualLen; // Laenge des beschriebenen Teils des Puffers
249*b1cdbd2cSJim Jagielski // Entspricht nBufSize, wenn EOF nicht
250*b1cdbd2cSJim Jagielski // ueberschritten wurde
251*b1cdbd2cSJim Jagielski sal_uInt16 nBufActualPos; // aktuelle Position im Puffer (0..nBufSize-1)
252*b1cdbd2cSJim Jagielski sal_uInt16 nBufFree; // freier Platz im Puffer fuer IO vom Typ eIOMode
253*b1cdbd2cSJim Jagielski unsigned int eIOMode:2; // STREAM_IO_*
254*b1cdbd2cSJim Jagielski
255*b1cdbd2cSJim Jagielski // Error-Codes, Konvertierung, Komprimierung, ...
256*b1cdbd2cSJim Jagielski int bIsDirty:1; // sal_True: Stream != Pufferinhalt
257*b1cdbd2cSJim Jagielski int bIsConsistent:1;// sal_False: Buffer enthaelt Daten, die NICHT
258*b1cdbd2cSJim Jagielski // per PutData in den abgeleiteten Stream
259*b1cdbd2cSJim Jagielski // geschrieben werden duerfen (siehe PutBack)
260*b1cdbd2cSJim Jagielski int bSwap:1;
261*b1cdbd2cSJim Jagielski int bIsEof:1;
262*b1cdbd2cSJim Jagielski sal_uInt32 nError;
263*b1cdbd2cSJim Jagielski sal_uInt16 nNumberFormatInt;
264*b1cdbd2cSJim Jagielski sal_uInt16 nCompressMode;
265*b1cdbd2cSJim Jagielski LineEnd eLineDelimiter;
266*b1cdbd2cSJim Jagielski CharSet eStreamCharSet;
267*b1cdbd2cSJim Jagielski // CharSet eTargetCharSet;
268*b1cdbd2cSJim Jagielski
269*b1cdbd2cSJim Jagielski // Verschluesselung
270*b1cdbd2cSJim Jagielski ByteString aKey; // aKey.Len != 0 -> Verschluesselung
271*b1cdbd2cSJim Jagielski unsigned char nCryptMask;
272*b1cdbd2cSJim Jagielski
273*b1cdbd2cSJim Jagielski // Formatierung von Strings
274*b1cdbd2cSJim Jagielski char cFiller;
275*b1cdbd2cSJim Jagielski sal_uInt8 nRadix;
276*b1cdbd2cSJim Jagielski sal_uInt8 nPrecision;
277*b1cdbd2cSJim Jagielski sal_uInt8 nWidth;
278*b1cdbd2cSJim Jagielski sal_uInt8 nPrintfParams;
279*b1cdbd2cSJim Jagielski sal_uInt8 nJustification;
280*b1cdbd2cSJim Jagielski ByteString aFormatString;
281*b1cdbd2cSJim Jagielski
282*b1cdbd2cSJim Jagielski // Userdata
283*b1cdbd2cSJim Jagielski long nVersion; // for external use
284*b1cdbd2cSJim Jagielski
285*b1cdbd2cSJim Jagielski // Hilfsmethoden
286*b1cdbd2cSJim Jagielski void CreateFormatString();
287*b1cdbd2cSJim Jagielski TOOLS_DLLPRIVATE void ImpInit();
288*b1cdbd2cSJim Jagielski
289*b1cdbd2cSJim Jagielski SvStream ( const SvStream& rStream ); // not implemented
290*b1cdbd2cSJim Jagielski SvStream& operator=( const SvStream& rStream ); // not implemented
291*b1cdbd2cSJim Jagielski
292*b1cdbd2cSJim Jagielski protected:
293*b1cdbd2cSJim Jagielski sal_Size nBufFilePos; // Fileposition von pBuf[0]
294*b1cdbd2cSJim Jagielski sal_uInt16 eStreamMode;
295*b1cdbd2cSJim Jagielski sal_Bool bIsWritable;
296*b1cdbd2cSJim Jagielski
297*b1cdbd2cSJim Jagielski virtual sal_Size GetData( void* pData, sal_Size nSize );
298*b1cdbd2cSJim Jagielski virtual sal_Size PutData( const void* pData, sal_Size nSize );
299*b1cdbd2cSJim Jagielski virtual sal_Size SeekPos( sal_Size nPos );
300*b1cdbd2cSJim Jagielski virtual void FlushData();
301*b1cdbd2cSJim Jagielski virtual void SetSize( sal_Size nSize );
302*b1cdbd2cSJim Jagielski
303*b1cdbd2cSJim Jagielski void ClearError();
304*b1cdbd2cSJim Jagielski void ClearBuffer();
305*b1cdbd2cSJim Jagielski
306*b1cdbd2cSJim Jagielski // verschluesselt & schreibt blockweise
307*b1cdbd2cSJim Jagielski sal_Size CryptAndWriteBuffer( const void* pStart, sal_Size nLen );
308*b1cdbd2cSJim Jagielski sal_Bool EncryptBuffer( void* pStart, sal_Size nLen );
309*b1cdbd2cSJim Jagielski
310*b1cdbd2cSJim Jagielski void SyncSvStream( sal_Size nNewStreamPos ); // SvStream <- Medium
311*b1cdbd2cSJim Jagielski void SyncSysStream(); // SvStream -> Medium
312*b1cdbd2cSJim Jagielski
313*b1cdbd2cSJim Jagielski public:
314*b1cdbd2cSJim Jagielski SvStream();
315*b1cdbd2cSJim Jagielski SvStream( SvLockBytes *pLockBytes);
316*b1cdbd2cSJim Jagielski virtual ~SvStream();
317*b1cdbd2cSJim Jagielski
318*b1cdbd2cSJim Jagielski ErrCode SetLockBytes( SvLockBytesRef& rBytes );
GetLockBytes() const319*b1cdbd2cSJim Jagielski SvLockBytes* GetLockBytes() const { return xLockBytes; }
320*b1cdbd2cSJim Jagielski
GetError() const321*b1cdbd2cSJim Jagielski sal_uInt32 GetError() const { return ERRCODE_TOERROR(nError); }
GetErrorCode() const322*b1cdbd2cSJim Jagielski sal_uInt32 GetErrorCode() const { return nError; }
323*b1cdbd2cSJim Jagielski
324*b1cdbd2cSJim Jagielski void SetError( sal_uInt32 nErrorCode );
325*b1cdbd2cSJim Jagielski virtual void ResetError();
326*b1cdbd2cSJim Jagielski
327*b1cdbd2cSJim Jagielski void SetNumberFormatInt( sal_uInt16 nNewFormat );
GetNumberFormatInt() const328*b1cdbd2cSJim Jagielski sal_uInt16 GetNumberFormatInt() const { return nNumberFormatInt; }
329*b1cdbd2cSJim Jagielski /// Enable/disable swapping of endians, may be needed for Unicode import/export
330*b1cdbd2cSJim Jagielski inline void SetEndianSwap( sal_Bool bVal );
331*b1cdbd2cSJim Jagielski // returns status of endian swap flag
IsEndianSwap() const332*b1cdbd2cSJim Jagielski sal_Bool IsEndianSwap() const { return 0 != bSwap; }
333*b1cdbd2cSJim Jagielski
SetCompressMode(sal_uInt16 nNewMode)334*b1cdbd2cSJim Jagielski void SetCompressMode( sal_uInt16 nNewMode )
335*b1cdbd2cSJim Jagielski { nCompressMode = nNewMode; }
GetCompressMode() const336*b1cdbd2cSJim Jagielski sal_uInt16 GetCompressMode() const { return nCompressMode; }
337*b1cdbd2cSJim Jagielski
338*b1cdbd2cSJim Jagielski void SetKey( const ByteString& rKey );
GetKey() const339*b1cdbd2cSJim Jagielski const ByteString& GetKey() const { return aKey; }
340*b1cdbd2cSJim Jagielski
SetStreamCharSet(CharSet eCharSet)341*b1cdbd2cSJim Jagielski void SetStreamCharSet( CharSet eCharSet )
342*b1cdbd2cSJim Jagielski { eStreamCharSet = eCharSet; }
GetStreamCharSet() const343*b1cdbd2cSJim Jagielski CharSet GetStreamCharSet() const { return eStreamCharSet; }
344*b1cdbd2cSJim Jagielski // void SetTargetCharSet( CharSet eCharSet )
345*b1cdbd2cSJim Jagielski // { eTargetCharSet = eCharSet; }
346*b1cdbd2cSJim Jagielski // CharSet GetTargetCharSet() const { return eTargetCharSet; }
347*b1cdbd2cSJim Jagielski
SetLineDelimiter(LineEnd eLineEnd)348*b1cdbd2cSJim Jagielski void SetLineDelimiter( LineEnd eLineEnd )
349*b1cdbd2cSJim Jagielski { eLineDelimiter = eLineEnd; }
GetLineDelimiter() const350*b1cdbd2cSJim Jagielski LineEnd GetLineDelimiter() const { return eLineDelimiter; }
351*b1cdbd2cSJim Jagielski
352*b1cdbd2cSJim Jagielski SvStream& operator>>( sal_uInt16& rUInt16 );
353*b1cdbd2cSJim Jagielski SvStream& operator>>( sal_uInt32& rUInt32 );
354*b1cdbd2cSJim Jagielski SvStream& operator>>( long& rLong );
355*b1cdbd2cSJim Jagielski SvStream& operator>>( short& rShort );
356*b1cdbd2cSJim Jagielski SvStream& operator>>( int& rInt );
357*b1cdbd2cSJim Jagielski SvStream& operator>>( signed char& rChar );
358*b1cdbd2cSJim Jagielski SvStream& operator>>( char& rChar );
359*b1cdbd2cSJim Jagielski SvStream& operator>>( unsigned char& rChar );
360*b1cdbd2cSJim Jagielski SvStream& operator>>( float& rFloat );
361*b1cdbd2cSJim Jagielski SvStream& operator>>( double& rDouble );
362*b1cdbd2cSJim Jagielski #ifdef ENABLE_BYTESTRING_STREAM_OPERATORS
operator >>(ByteString & rString)363*b1cdbd2cSJim Jagielski SvStream& operator>>( ByteString& rString ) { return ReadByteString(rString); }
364*b1cdbd2cSJim Jagielski #endif
365*b1cdbd2cSJim Jagielski #ifdef ENABLE_STRING_STREAM_OPERATORS
operator >>(UniString & rString)366*b1cdbd2cSJim Jagielski SvStream& operator>>( UniString& rString ) { return ReadByteString(rString); }
367*b1cdbd2cSJim Jagielski #endif
368*b1cdbd2cSJim Jagielski SvStream& operator>>( SvStream& rStream );
369*b1cdbd2cSJim Jagielski
370*b1cdbd2cSJim Jagielski SvStream& operator<<( sal_uInt16 nUInt16 );
371*b1cdbd2cSJim Jagielski SvStream& operator<<( sal_uInt32 nUInt32 );
372*b1cdbd2cSJim Jagielski SvStream& operator<<( long nLong );
373*b1cdbd2cSJim Jagielski SvStream& operator<<( short nShort );
374*b1cdbd2cSJim Jagielski SvStream& operator<<( int nInt );
375*b1cdbd2cSJim Jagielski SvStream& operator<<( signed char nChar );
376*b1cdbd2cSJim Jagielski SvStream& operator<<( char nChar );
377*b1cdbd2cSJim Jagielski SvStream& operator<<( unsigned char nChar );
378*b1cdbd2cSJim Jagielski SvStream& operator<<( float nFloat );
379*b1cdbd2cSJim Jagielski SvStream& operator<<( const double& rDouble );
380*b1cdbd2cSJim Jagielski SvStream& operator<<( const char* pBuf );
381*b1cdbd2cSJim Jagielski SvStream& operator<<( const unsigned char* pBuf );
382*b1cdbd2cSJim Jagielski #ifdef ENABLE_BYTESTRING_STREAM_OPERATORS
operator <<(const ByteString & rString)383*b1cdbd2cSJim Jagielski SvStream& operator<<( const ByteString& rString ) { return WriteByteString( rString ); }
384*b1cdbd2cSJim Jagielski #endif
385*b1cdbd2cSJim Jagielski #ifdef ENABLE_STRING_STREAM_OPERATORS
operator <<(const UniString & rString)386*b1cdbd2cSJim Jagielski SvStream& operator<<( const UniString& rString ) { return WriteByteString(rString); }
387*b1cdbd2cSJim Jagielski #endif
388*b1cdbd2cSJim Jagielski SvStream& operator<<( SvStream& rStream );
389*b1cdbd2cSJim Jagielski
390*b1cdbd2cSJim Jagielski SvStream& ReadByteString( UniString& rStr, rtl_TextEncoding eSrcCharSet );
ReadByteString(UniString & rStr)391*b1cdbd2cSJim Jagielski SvStream& ReadByteString( UniString& rStr ) { return ReadByteString( rStr, GetStreamCharSet() ); }
392*b1cdbd2cSJim Jagielski SvStream& ReadByteString( ByteString& rStr );
393*b1cdbd2cSJim Jagielski SvStream& WriteByteString( const UniString& rStr, rtl_TextEncoding eDestCharSet );
WriteByteString(const UniString & rStr)394*b1cdbd2cSJim Jagielski SvStream& WriteByteString( const UniString& rStr ) { return WriteByteString( rStr, GetStreamCharSet() ); }
395*b1cdbd2cSJim Jagielski SvStream& WriteByteString( const ByteString& rStr );
396*b1cdbd2cSJim Jagielski
SetRadix(sal_uInt8 nRad)397*b1cdbd2cSJim Jagielski void SetRadix( sal_uInt8 nRad )
398*b1cdbd2cSJim Jagielski { nRadix = nRad; CreateFormatString(); }
GetRadix() const399*b1cdbd2cSJim Jagielski sal_uInt8 GetRadix() const { return nRadix; }
SetPrecision(sal_uInt8 nPrec)400*b1cdbd2cSJim Jagielski void SetPrecision( sal_uInt8 nPrec )
401*b1cdbd2cSJim Jagielski { nPrecision = nPrec; CreateFormatString(); }
GetPrecision() const402*b1cdbd2cSJim Jagielski sal_uInt8 GetPrecision() const { return nPrecision; }
SetWidth(sal_uInt8 nWid)403*b1cdbd2cSJim Jagielski void SetWidth( sal_uInt8 nWid)
404*b1cdbd2cSJim Jagielski { nWidth = nWid; CreateFormatString(); }
GetWidth() const405*b1cdbd2cSJim Jagielski sal_uInt8 GetWidth() const { return nWidth; }
SetFiller(char cFil)406*b1cdbd2cSJim Jagielski void SetFiller( char cFil )
407*b1cdbd2cSJim Jagielski { cFiller = cFil; CreateFormatString(); }
GetFiller() const408*b1cdbd2cSJim Jagielski char GetFiller() const { return cFiller; }
SetJustification(sal_uInt8 nJus)409*b1cdbd2cSJim Jagielski void SetJustification( sal_uInt8 nJus )
410*b1cdbd2cSJim Jagielski { nJustification = nJus; CreateFormatString(); }
GetJustification() const411*b1cdbd2cSJim Jagielski sal_uInt8 GetJustification() const { return nJustification; }
412*b1cdbd2cSJim Jagielski
413*b1cdbd2cSJim Jagielski SvStream& ReadNumber( short& rShort );
414*b1cdbd2cSJim Jagielski SvStream& ReadNumber( sal_uInt16& rUInt16 );
415*b1cdbd2cSJim Jagielski SvStream& ReadNumber( long& rLong );
416*b1cdbd2cSJim Jagielski SvStream& ReadNumber( sal_uInt32& rUInt32 );
417*b1cdbd2cSJim Jagielski SvStream& ReadNumber( int& rInt );
418*b1cdbd2cSJim Jagielski SvStream& ReadNumber( float& rFloat );
419*b1cdbd2cSJim Jagielski SvStream& ReadNumber( double& rDouble );
420*b1cdbd2cSJim Jagielski
421*b1cdbd2cSJim Jagielski SvStream& WriteNumber( short nShort );
422*b1cdbd2cSJim Jagielski SvStream& WriteNumber( sal_uInt16 nUInt16 );
423*b1cdbd2cSJim Jagielski SvStream& WriteNumber( long nLong );
424*b1cdbd2cSJim Jagielski SvStream& WriteNumber( sal_uInt32 nUInt32 );
425*b1cdbd2cSJim Jagielski SvStream& WriteNumber( int nInt );
426*b1cdbd2cSJim Jagielski SvStream& WriteNumber( float nFloat );
427*b1cdbd2cSJim Jagielski SvStream& WriteNumber( const double& rDouble );
428*b1cdbd2cSJim Jagielski
429*b1cdbd2cSJim Jagielski sal_Size Read( void* pData, sal_Size nSize );
430*b1cdbd2cSJim Jagielski sal_Size Write( const void* pData, sal_Size nSize );
431*b1cdbd2cSJim Jagielski sal_Size Seek( sal_Size nPos );
432*b1cdbd2cSJim Jagielski sal_Size SeekRel( sal_sSize nPos );
Tell() const433*b1cdbd2cSJim Jagielski sal_Size Tell() const { return nBufFilePos+nBufActualPos; }
434*b1cdbd2cSJim Jagielski void Flush();
IsEof() const435*b1cdbd2cSJim Jagielski sal_Bool IsEof() const { return bIsEof; }
436*b1cdbd2cSJim Jagielski // next Tell() <= nSize
437*b1cdbd2cSJim Jagielski sal_Bool SetStreamSize( sal_Size nSize );
438*b1cdbd2cSJim Jagielski
439*b1cdbd2cSJim Jagielski /// Read in the stream to a zero character and put all
440*b1cdbd2cSJim Jagielski /// read chracters in the Bytestring. The String interface
441*b1cdbd2cSJim Jagielski /// convert the BytString with the given encoding to a String
442*b1cdbd2cSJim Jagielski sal_Bool ReadCString( ByteString& rStr );
443*b1cdbd2cSJim Jagielski sal_Bool ReadCString( String& rStr, rtl_TextEncoding eToEncode );
ReadCString(String & rStr)444*b1cdbd2cSJim Jagielski sal_Bool ReadCString( String& rStr ) { return ReadCString( rStr, GetStreamCharSet()); }
445*b1cdbd2cSJim Jagielski
446*b1cdbd2cSJim Jagielski sal_Bool ReadLine( ByteString& rStr );
447*b1cdbd2cSJim Jagielski sal_Bool WriteLine( const ByteString& rStr );
448*b1cdbd2cSJim Jagielski sal_Bool WriteLines( const ByteString& rStr );
449*b1cdbd2cSJim Jagielski
450*b1cdbd2cSJim Jagielski sal_Bool ReadByteStringLine( String& rStr, rtl_TextEncoding eSrcCharSet );
ReadByteStringLine(String & rStr)451*b1cdbd2cSJim Jagielski sal_Bool ReadByteStringLine( String& rStr ) { return ReadByteStringLine( rStr, GetStreamCharSet()); }
452*b1cdbd2cSJim Jagielski sal_Bool WriteByteStringLine( const String& rStr, rtl_TextEncoding eDestCharSet );
WriteByteStringLine(const String & rStr)453*b1cdbd2cSJim Jagielski sal_Bool WriteByteStringLine( const String& rStr ) { return WriteByteStringLine( rStr, GetStreamCharSet()); }
454*b1cdbd2cSJim Jagielski sal_Bool WriteByteStringLines( const String& rStr, rtl_TextEncoding eDestCharSet );
WriteByteStringLines(const String & rStr)455*b1cdbd2cSJim Jagielski sal_Bool WriteByteStringLines( const String& rStr ) { return WriteByteStringLine( rStr, GetStreamCharSet()); }
456*b1cdbd2cSJim Jagielski
457*b1cdbd2cSJim Jagielski /// Switch to no endian swapping and write 0xfeff
458*b1cdbd2cSJim Jagielski sal_Bool StartWritingUnicodeText();
459*b1cdbd2cSJim Jagielski
460*b1cdbd2cSJim Jagielski /** If eReadBomCharSet==RTL_TEXTENCODING_DONTKNOW: read 16bit,
461*b1cdbd2cSJim Jagielski if 0xfeff do nothing (UTF-16), if 0xfffe switch endian
462*b1cdbd2cSJim Jagielski swapping (UTF-16), if 0xefbb or 0xbbef read another byte
463*b1cdbd2cSJim Jagielski and check for UTF-8. If no UTF-* BOM was detected put all
464*b1cdbd2cSJim Jagielski read bytes back. This means that if 2 bytes were read it
465*b1cdbd2cSJim Jagielski was an UTF-16 BOM, if 3 bytes were read it was an UTF-8
466*b1cdbd2cSJim Jagielski BOM. There is no UTF-7, UTF-32 or UTF-EBCDIC BOM detection!
467*b1cdbd2cSJim Jagielski
468*b1cdbd2cSJim Jagielski If eReadBomCharSet!=RTL_TEXTENCODING_DONTKNOW: only read a
469*b1cdbd2cSJim Jagielski BOM of that encoding and switch endian swapping if UTF-16
470*b1cdbd2cSJim Jagielski and 0xfffe.
471*b1cdbd2cSJim Jagielski */
472*b1cdbd2cSJim Jagielski sal_Bool StartReadingUnicodeText( rtl_TextEncoding eReadBomCharSet );
473*b1cdbd2cSJim Jagielski
474*b1cdbd2cSJim Jagielski /// Read a line of Unicode
475*b1cdbd2cSJim Jagielski sal_Bool ReadUniStringLine( String& rStr );
476*b1cdbd2cSJim Jagielski /// Read a line of Unicode if eSrcCharSet==RTL_TEXTENCODING_UNICODE,
477*b1cdbd2cSJim Jagielski /// otherwise read a line of Bytecode and convert from eSrcCharSet
478*b1cdbd2cSJim Jagielski sal_Bool ReadUniOrByteStringLine( String& rStr, rtl_TextEncoding eSrcCharSet );
ReadUniOrByteStringLine(String & rStr)479*b1cdbd2cSJim Jagielski sal_Bool ReadUniOrByteStringLine( String& rStr )
480*b1cdbd2cSJim Jagielski { return ReadUniOrByteStringLine( rStr, GetStreamCharSet() ); }
481*b1cdbd2cSJim Jagielski /// Write a sequence of Unicode characters
482*b1cdbd2cSJim Jagielski sal_Bool WriteUnicodeText( const String& rStr );
483*b1cdbd2cSJim Jagielski /// Write a sequence of Unicode characters if eDestCharSet==RTL_TEXTENCODING_UNICODE,
484*b1cdbd2cSJim Jagielski /// otherwise write a sequence of Bytecodes converted to eDestCharSet
485*b1cdbd2cSJim Jagielski sal_Bool WriteUnicodeOrByteText( const String& rStr, rtl_TextEncoding eDestCharSet );
WriteUnicodeOrByteText(const String & rStr)486*b1cdbd2cSJim Jagielski sal_Bool WriteUnicodeOrByteText( const String& rStr )
487*b1cdbd2cSJim Jagielski { return WriteUnicodeOrByteText( rStr, GetStreamCharSet() ); }
488*b1cdbd2cSJim Jagielski /// Write a line of Unicode and append line end (endlu())
489*b1cdbd2cSJim Jagielski sal_Bool WriteUniStringLine( const String& rStr );
490*b1cdbd2cSJim Jagielski /// Write multiple lines of Unicode (with CovertLineEnd) and append line end (endlu())
491*b1cdbd2cSJim Jagielski sal_Bool WriteUniStringLines( const String& rStr );
492*b1cdbd2cSJim Jagielski /// Write a line of Unicode if eDestCharSet==RTL_TEXTENCODING_UNICODE,
493*b1cdbd2cSJim Jagielski /// otherwise write a line of Bytecode converted to eDestCharSet
494*b1cdbd2cSJim Jagielski sal_Bool WriteUniOrByteStringLine( const String& rStr, rtl_TextEncoding eDestCharSet );
WriteUniOrByteStringLine(const String & rStr)495*b1cdbd2cSJim Jagielski sal_Bool WriteUniOrByteStringLine( const String& rStr )
496*b1cdbd2cSJim Jagielski { return WriteUniOrByteStringLine( rStr, GetStreamCharSet() ); }
497*b1cdbd2cSJim Jagielski /// Write multiple lines of Unicode if eDestCharSet==RTL_TEXTENCODING_UNICODE,
498*b1cdbd2cSJim Jagielski /// otherwise write multiple lines of Bytecode converted to eDestCharSet,
499*b1cdbd2cSJim Jagielski /// CovertLineEnd is applied.
500*b1cdbd2cSJim Jagielski sal_Bool WriteUniOrByteStringLines( const String& rStr, rtl_TextEncoding eDestCharSet );
WriteUniOrByteStringLines(const String & rStr)501*b1cdbd2cSJim Jagielski sal_Bool WriteUniOrByteStringLines( const String& rStr )
502*b1cdbd2cSJim Jagielski { return WriteUniOrByteStringLines( rStr, GetStreamCharSet() ); }
503*b1cdbd2cSJim Jagielski /// Write a Unicode character if eDestCharSet==RTL_TEXTENCODING_UNICODE,
504*b1cdbd2cSJim Jagielski /// otherwise write as Bytecode converted to eDestCharSet.
505*b1cdbd2cSJim Jagielski /// This may result in more than one byte being written
506*b1cdbd2cSJim Jagielski /// if a multi byte encoding (e.g. UTF7, UTF8) is chosen.
507*b1cdbd2cSJim Jagielski sal_Bool WriteUniOrByteChar( sal_Unicode ch, rtl_TextEncoding eDestCharSet );
WriteUniOrByteChar(sal_Unicode ch)508*b1cdbd2cSJim Jagielski sal_Bool WriteUniOrByteChar( sal_Unicode ch )
509*b1cdbd2cSJim Jagielski { return WriteUniOrByteChar( ch, GetStreamCharSet() ); }
510*b1cdbd2cSJim Jagielski
511*b1cdbd2cSJim Jagielski /** Read a CSV (comma separated values) data line using
512*b1cdbd2cSJim Jagielski ReadUniOrByteStringLine().
513*b1cdbd2cSJim Jagielski
514*b1cdbd2cSJim Jagielski @param bEmbeddedLineBreak
515*b1cdbd2cSJim Jagielski If sal_True and a line-break occurs inside a field of data,
516*b1cdbd2cSJim Jagielski a line feed LF '\n' and the next line are appended. Repeats
517*b1cdbd2cSJim Jagielski until a line-break is not in a field. A field is determined
518*b1cdbd2cSJim Jagielski by delimiting rFieldSeparators and optionally surrounded by
519*b1cdbd2cSJim Jagielski a pair of cFieldQuote characters. For a line-break to be
520*b1cdbd2cSJim Jagielski within a field, the field content MUST be surrounded by
521*b1cdbd2cSJim Jagielski cFieldQuote characters, and the opening cFieldQuote MUST be
522*b1cdbd2cSJim Jagielski at the very start of a line or follow right behind a field
523*b1cdbd2cSJim Jagielski separator with no extra characters in between. Anything,
524*b1cdbd2cSJim Jagielski including field separators and escaped quotes (by doubling
525*b1cdbd2cSJim Jagielski them, or preceding them with a backslash if
526*b1cdbd2cSJim Jagielski bAllowBackslashEscape==sal_True) may appear in a quoted
527*b1cdbd2cSJim Jagielski field.
528*b1cdbd2cSJim Jagielski
529*b1cdbd2cSJim Jagielski If bEmbeddedLineBreak==sal_False, nothing is parsed and the
530*b1cdbd2cSJim Jagielski string returned is simply one ReadUniOrByteStringLine().
531*b1cdbd2cSJim Jagielski
532*b1cdbd2cSJim Jagielski @param rFieldSeparators
533*b1cdbd2cSJim Jagielski A list of characters that each may act as a field separator.
534*b1cdbd2cSJim Jagielski
535*b1cdbd2cSJim Jagielski @param cFieldQuote
536*b1cdbd2cSJim Jagielski The quote character used.
537*b1cdbd2cSJim Jagielski
538*b1cdbd2cSJim Jagielski @param bAllowBackslashEscape
539*b1cdbd2cSJim Jagielski If sal_True, an embedded quote character inside a quoted
540*b1cdbd2cSJim Jagielski field may also be escaped with a preceding backslash.
541*b1cdbd2cSJim Jagielski Normally, quotes are escaped by doubling them.
542*b1cdbd2cSJim Jagielski
543*b1cdbd2cSJim Jagielski @return
544*b1cdbd2cSJim Jagielski sal_True if no stream error.
545*b1cdbd2cSJim Jagielski
546*b1cdbd2cSJim Jagielski @ATTENTION
547*b1cdbd2cSJim Jagielski Note that the string returned may be truncated even inside
548*b1cdbd2cSJim Jagielski a quoted field if STRING_MAXLEN was reached. There
549*b1cdbd2cSJim Jagielski currently is no way to exactly determine the conditions,
550*b1cdbd2cSJim Jagielski whether this was at a line end, or whether open quotes
551*b1cdbd2cSJim Jagielski would have closed the field before the line end, as even a
552*b1cdbd2cSJim Jagielski ReadUniOrByteStringLine() may return prematurely but the
553*b1cdbd2cSJim Jagielski stream was positioned ahead until the real end of line.
554*b1cdbd2cSJim Jagielski Additionally, due to character encoding conversions, string
555*b1cdbd2cSJim Jagielski length and bytes read don't necessarily match, and
556*b1cdbd2cSJim Jagielski resyncing to a previous position matching the string's
557*b1cdbd2cSJim Jagielski length isn't always possible. As a result, a logical line
558*b1cdbd2cSJim Jagielski with embedded line breaks and more than STRING_MAXLEN
559*b1cdbd2cSJim Jagielski characters will be spoiled, and a subsequent ReadCsvLine()
560*b1cdbd2cSJim Jagielski may start under false preconditions.
561*b1cdbd2cSJim Jagielski */
562*b1cdbd2cSJim Jagielski sal_Bool ReadCsvLine( String& rStr, sal_Bool bEmbeddedLineBreak,
563*b1cdbd2cSJim Jagielski const String& rFieldSeparators, sal_Unicode cFieldQuote,
564*b1cdbd2cSJim Jagielski sal_Bool bAllowBackslashEscape = sal_False);
565*b1cdbd2cSJim Jagielski
566*b1cdbd2cSJim Jagielski void SetBufferSize( sal_uInt16 nBufSize );
GetBufferSize() const567*b1cdbd2cSJim Jagielski sal_uInt16 GetBufferSize() const { return nBufSize; }
568*b1cdbd2cSJim Jagielski
569*b1cdbd2cSJim Jagielski void RefreshBuffer();
570*b1cdbd2cSJim Jagielski SvStream& PutBack( char aCh );
571*b1cdbd2cSJim Jagielski void EatWhite();
572*b1cdbd2cSJim Jagielski
IsWritable() const573*b1cdbd2cSJim Jagielski sal_Bool IsWritable() const { return bIsWritable; }
GetStreamMode() const574*b1cdbd2cSJim Jagielski StreamMode GetStreamMode() const { return eStreamMode; }
575*b1cdbd2cSJim Jagielski virtual sal_uInt16 IsA() const;
576*b1cdbd2cSJim Jagielski
GetVersion()577*b1cdbd2cSJim Jagielski long GetVersion() { return nVersion; }
SetVersion(long n)578*b1cdbd2cSJim Jagielski void SetVersion( long n ) { nVersion = n; }
579*b1cdbd2cSJim Jagielski
580*b1cdbd2cSJim Jagielski /** Add a mark to indicate to which position in the stream you want to be
581*b1cdbd2cSJim Jagielski able to seek back.
582*b1cdbd2cSJim Jagielski
583*b1cdbd2cSJim Jagielski @descr If you set a mark at nPos, you indicate to the stream that you
584*b1cdbd2cSJim Jagielski won't issue seek operations to any position 'before' nPos. This can
585*b1cdbd2cSJim Jagielski be exploited by 'transient streams' that do not permanently store
586*b1cdbd2cSJim Jagielski their data; they can discard any buffered data up to nPos.
587*b1cdbd2cSJim Jagielski
588*b1cdbd2cSJim Jagielski @descr However, if the stream is already positioned past nPos, this
589*b1cdbd2cSJim Jagielski method is not guaranteed to have the desired effect. A 'transient
590*b1cdbd2cSJim Jagielski stream' may have already discarded the buffered data at nPos, so that
591*b1cdbd2cSJim Jagielski a seek operation to nPos will fail nonetheless.
592*b1cdbd2cSJim Jagielski
593*b1cdbd2cSJim Jagielski @descr There can be more than one mark for a stream, indicating that
594*b1cdbd2cSJim Jagielski you want to be able to seek back in the stream as far as the 'lowest'
595*b1cdbd2cSJim Jagielski off all the marks. There can even be multiple marks at the same
596*b1cdbd2cSJim Jagielski position (and they must all be individually removed with
597*b1cdbd2cSJim Jagielski RemoveMark()).
598*b1cdbd2cSJim Jagielski
599*b1cdbd2cSJim Jagielski @param nPos The position in the stream at which to add a mark.
600*b1cdbd2cSJim Jagielski */
601*b1cdbd2cSJim Jagielski virtual void AddMark(sal_Size nPos);
602*b1cdbd2cSJim Jagielski
603*b1cdbd2cSJim Jagielski /** Remove a mark introduced with AddMark().
604*b1cdbd2cSJim Jagielski
605*b1cdbd2cSJim Jagielski @descr If you no longer need to seek back to some position for which
606*b1cdbd2cSJim Jagielski you added a mark, you should remove that mark. (And a 'transient
607*b1cdbd2cSJim Jagielski stream' that does not permanently store its data can then potentially
608*b1cdbd2cSJim Jagielski discard some of its buffered data.)
609*b1cdbd2cSJim Jagielski
610*b1cdbd2cSJim Jagielski @descr Removing one mark does not have any effects on any other
611*b1cdbd2cSJim Jagielski marks. Especially, if you have multiple marks at the same position,
612*b1cdbd2cSJim Jagielski you must call this method multiple times to effectively 'unmark' that
613*b1cdbd2cSJim Jagielski position.
614*b1cdbd2cSJim Jagielski
615*b1cdbd2cSJim Jagielski @descr If you specify a position for which there is no mark, this
616*b1cdbd2cSJim Jagielski method simply has no effect.
617*b1cdbd2cSJim Jagielski
618*b1cdbd2cSJim Jagielski @param nPos The position in the stream at which to remove the mark.
619*b1cdbd2cSJim Jagielski */
620*b1cdbd2cSJim Jagielski virtual void RemoveMark(sal_Size nPos);
621*b1cdbd2cSJim Jagielski
622*b1cdbd2cSJim Jagielski friend SvStream& operator<<( SvStream& rStr, SvStrPtr f ); // fuer Manips
623*b1cdbd2cSJim Jagielski };
624*b1cdbd2cSJim Jagielski
operator <<(SvStream & rStr,SvStrPtr f)625*b1cdbd2cSJim Jagielski inline SvStream& operator<<( SvStream& rStr, SvStrPtr f )
626*b1cdbd2cSJim Jagielski {
627*b1cdbd2cSJim Jagielski (*f)(rStr);
628*b1cdbd2cSJim Jagielski return rStr;
629*b1cdbd2cSJim Jagielski }
630*b1cdbd2cSJim Jagielski
ReadNumber(short & rShort)631*b1cdbd2cSJim Jagielski inline SvStream& SvStream::ReadNumber( short& rShort )
632*b1cdbd2cSJim Jagielski {
633*b1cdbd2cSJim Jagielski long nTmp;
634*b1cdbd2cSJim Jagielski ReadNumber( nTmp );
635*b1cdbd2cSJim Jagielski rShort = (short)nTmp;
636*b1cdbd2cSJim Jagielski return *this;
637*b1cdbd2cSJim Jagielski }
638*b1cdbd2cSJim Jagielski
ReadNumber(sal_uInt16 & rUShort)639*b1cdbd2cSJim Jagielski inline SvStream& SvStream::ReadNumber( sal_uInt16& rUShort )
640*b1cdbd2cSJim Jagielski {
641*b1cdbd2cSJim Jagielski sal_uInt32 nTmp;
642*b1cdbd2cSJim Jagielski ReadNumber( nTmp );
643*b1cdbd2cSJim Jagielski rUShort = (sal_uInt16)nTmp;
644*b1cdbd2cSJim Jagielski return *this;
645*b1cdbd2cSJim Jagielski }
646*b1cdbd2cSJim Jagielski
ReadNumber(int & rInt)647*b1cdbd2cSJim Jagielski inline SvStream& SvStream::ReadNumber( int& rInt )
648*b1cdbd2cSJim Jagielski {
649*b1cdbd2cSJim Jagielski long nTmp;
650*b1cdbd2cSJim Jagielski ReadNumber( nTmp );
651*b1cdbd2cSJim Jagielski rInt = (int)nTmp;
652*b1cdbd2cSJim Jagielski return *this;
653*b1cdbd2cSJim Jagielski }
654*b1cdbd2cSJim Jagielski
655*b1cdbd2cSJim Jagielski /*
656*b1cdbd2cSJim Jagielski inline SvStream& SvStream::ReadNumber( unsigned int& rUInt )
657*b1cdbd2cSJim Jagielski {
658*b1cdbd2cSJim Jagielski sal_uIntPtr nTmp;
659*b1cdbd2cSJim Jagielski ReadNumber( nTmp );
660*b1cdbd2cSJim Jagielski rUInt = (unsigned int)nTmp;
661*b1cdbd2cSJim Jagielski return *this;
662*b1cdbd2cSJim Jagielski }
663*b1cdbd2cSJim Jagielski */
664*b1cdbd2cSJim Jagielski
ReadNumber(float & rFloat)665*b1cdbd2cSJim Jagielski inline SvStream& SvStream::ReadNumber( float& rFloat )
666*b1cdbd2cSJim Jagielski {
667*b1cdbd2cSJim Jagielski double nTmp;
668*b1cdbd2cSJim Jagielski ReadNumber( nTmp );
669*b1cdbd2cSJim Jagielski rFloat = (float)nTmp;
670*b1cdbd2cSJim Jagielski return *this;
671*b1cdbd2cSJim Jagielski }
672*b1cdbd2cSJim Jagielski
WriteNumber(short nShort)673*b1cdbd2cSJim Jagielski inline SvStream& SvStream::WriteNumber( short nShort )
674*b1cdbd2cSJim Jagielski {
675*b1cdbd2cSJim Jagielski WriteNumber( (long)nShort );
676*b1cdbd2cSJim Jagielski return *this;
677*b1cdbd2cSJim Jagielski }
678*b1cdbd2cSJim Jagielski
WriteNumber(sal_uInt16 nUShort)679*b1cdbd2cSJim Jagielski inline SvStream& SvStream::WriteNumber( sal_uInt16 nUShort )
680*b1cdbd2cSJim Jagielski {
681*b1cdbd2cSJim Jagielski WriteNumber( (sal_uInt32)nUShort );
682*b1cdbd2cSJim Jagielski return *this;
683*b1cdbd2cSJim Jagielski }
684*b1cdbd2cSJim Jagielski
WriteNumber(int nInt)685*b1cdbd2cSJim Jagielski inline SvStream& SvStream::WriteNumber( int nInt )
686*b1cdbd2cSJim Jagielski {
687*b1cdbd2cSJim Jagielski WriteNumber( (long)nInt );
688*b1cdbd2cSJim Jagielski return *this;
689*b1cdbd2cSJim Jagielski }
690*b1cdbd2cSJim Jagielski
691*b1cdbd2cSJim Jagielski /*
692*b1cdbd2cSJim Jagielski inline SvStream& SvStream::WriteNumber( unsigned int nUInt )
693*b1cdbd2cSJim Jagielski {
694*b1cdbd2cSJim Jagielski WriteNumber( (sal_uIntPtr)nUInt );
695*b1cdbd2cSJim Jagielski return *this;
696*b1cdbd2cSJim Jagielski }
697*b1cdbd2cSJim Jagielski */
698*b1cdbd2cSJim Jagielski
WriteNumber(float nFloat)699*b1cdbd2cSJim Jagielski inline SvStream& SvStream::WriteNumber( float nFloat )
700*b1cdbd2cSJim Jagielski {
701*b1cdbd2cSJim Jagielski double nTemp = nFloat;
702*b1cdbd2cSJim Jagielski WriteNumber( nTemp );
703*b1cdbd2cSJim Jagielski return *this;
704*b1cdbd2cSJim Jagielski }
705*b1cdbd2cSJim Jagielski
SetEndianSwap(sal_Bool bVal)706*b1cdbd2cSJim Jagielski inline void SvStream::SetEndianSwap( sal_Bool bVal )
707*b1cdbd2cSJim Jagielski {
708*b1cdbd2cSJim Jagielski #ifdef OSL_BIGENDIAN
709*b1cdbd2cSJim Jagielski SetNumberFormatInt( bVal ? NUMBERFORMAT_INT_LITTLEENDIAN : NUMBERFORMAT_INT_BIGENDIAN );
710*b1cdbd2cSJim Jagielski #else
711*b1cdbd2cSJim Jagielski SetNumberFormatInt( bVal ? NUMBERFORMAT_INT_BIGENDIAN : NUMBERFORMAT_INT_LITTLEENDIAN );
712*b1cdbd2cSJim Jagielski #endif
713*b1cdbd2cSJim Jagielski }
714*b1cdbd2cSJim Jagielski
715*b1cdbd2cSJim Jagielski TOOLS_DLLPUBLIC SvStream& endl( SvStream& rStr );
716*b1cdbd2cSJim Jagielski /// same as endl() but Unicode
717*b1cdbd2cSJim Jagielski TOOLS_DLLPUBLIC SvStream& endlu( SvStream& rStr );
718*b1cdbd2cSJim Jagielski /// call endlu() if eStreamCharSet==RTL_TEXTECODING_UNICODE otherwise endl()
719*b1cdbd2cSJim Jagielski TOOLS_DLLPUBLIC SvStream& endlub( SvStream& rStr );
720*b1cdbd2cSJim Jagielski
721*b1cdbd2cSJim Jagielski // --------------
722*b1cdbd2cSJim Jagielski // - FileStream -
723*b1cdbd2cSJim Jagielski // --------------
724*b1cdbd2cSJim Jagielski
725*b1cdbd2cSJim Jagielski class TOOLS_DLLPUBLIC SvFileStream : public SvStream
726*b1cdbd2cSJim Jagielski {
727*b1cdbd2cSJim Jagielski friend class ImpEaMgr;
728*b1cdbd2cSJim Jagielski friend class CORmFileStream;
729*b1cdbd2cSJim Jagielski friend class FileCopier;
730*b1cdbd2cSJim Jagielski
731*b1cdbd2cSJim Jagielski private:
732*b1cdbd2cSJim Jagielski StreamData* pInstanceData;
733*b1cdbd2cSJim Jagielski String aFilename;
734*b1cdbd2cSJim Jagielski sal_uInt16 nLockCounter;
735*b1cdbd2cSJim Jagielski sal_Bool bIsOpen;
736*b1cdbd2cSJim Jagielski sal_uInt32 GetFileHandle() const;
737*b1cdbd2cSJim Jagielski
738*b1cdbd2cSJim Jagielski // Forbidden and not implemented.
739*b1cdbd2cSJim Jagielski SvFileStream (const SvFileStream&);
740*b1cdbd2cSJim Jagielski SvFileStream & operator= (const SvFileStream&);
741*b1cdbd2cSJim Jagielski
742*b1cdbd2cSJim Jagielski protected:
743*b1cdbd2cSJim Jagielski
744*b1cdbd2cSJim Jagielski virtual sal_Size GetData( void* pData, sal_Size nSize );
745*b1cdbd2cSJim Jagielski virtual sal_Size PutData( const void* pData, sal_Size nSize );
746*b1cdbd2cSJim Jagielski virtual sal_Size SeekPos( sal_Size nPos );
747*b1cdbd2cSJim Jagielski virtual void SetSize( sal_Size nSize );
748*b1cdbd2cSJim Jagielski virtual void FlushData();
749*b1cdbd2cSJim Jagielski
750*b1cdbd2cSJim Jagielski public:
751*b1cdbd2cSJim Jagielski // Schaltet bei fehlgeschlagenem Schreiboeffnen auf Lesen zurueck
752*b1cdbd2cSJim Jagielski SvFileStream( const String& rFileName, StreamMode eOpenMode );
753*b1cdbd2cSJim Jagielski SvFileStream();
754*b1cdbd2cSJim Jagielski ~SvFileStream();
755*b1cdbd2cSJim Jagielski
756*b1cdbd2cSJim Jagielski virtual void ResetError();
757*b1cdbd2cSJim Jagielski
758*b1cdbd2cSJim Jagielski sal_Bool LockRange( sal_Size nByteOffset, sal_Size nBytes );
759*b1cdbd2cSJim Jagielski sal_Bool UnlockRange( sal_Size nByteOffset, sal_Size nBytes );
760*b1cdbd2cSJim Jagielski sal_Bool LockFile();
761*b1cdbd2cSJim Jagielski sal_Bool UnlockFile();
762*b1cdbd2cSJim Jagielski
763*b1cdbd2cSJim Jagielski void Open( const String& rFileName, StreamMode eOpenMode );
764*b1cdbd2cSJim Jagielski void Close();
765*b1cdbd2cSJim Jagielski void ReOpen(); // Aufruf nach Close, FilePointer == 0
IsOpen() const766*b1cdbd2cSJim Jagielski sal_Bool IsOpen() const { return bIsOpen; }
IsLocked() const767*b1cdbd2cSJim Jagielski sal_Bool IsLocked() const { return ( nLockCounter!=0 ); }
768*b1cdbd2cSJim Jagielski virtual sal_uInt16 IsA() const;
769*b1cdbd2cSJim Jagielski
GetFileName() const770*b1cdbd2cSJim Jagielski const String& GetFileName() const { return aFilename; }
771*b1cdbd2cSJim Jagielski };
772*b1cdbd2cSJim Jagielski
773*b1cdbd2cSJim Jagielski // ----------------
774*b1cdbd2cSJim Jagielski // - MemoryStream -
775*b1cdbd2cSJim Jagielski // ----------------
776*b1cdbd2cSJim Jagielski
777*b1cdbd2cSJim Jagielski class TOOLS_DLLPUBLIC SvMemoryStream : public SvStream
778*b1cdbd2cSJim Jagielski {
779*b1cdbd2cSJim Jagielski // Forbidden and not implemented.
780*b1cdbd2cSJim Jagielski SvMemoryStream (const SvMemoryStream&);
781*b1cdbd2cSJim Jagielski SvMemoryStream & operator= (const SvMemoryStream&);
782*b1cdbd2cSJim Jagielski
783*b1cdbd2cSJim Jagielski friend class SvCacheStream;
GetSize() const784*b1cdbd2cSJim Jagielski sal_Size GetSize() const { return nSize; }
785*b1cdbd2cSJim Jagielski
786*b1cdbd2cSJim Jagielski protected:
787*b1cdbd2cSJim Jagielski sal_Size nSize;
788*b1cdbd2cSJim Jagielski sal_Size nResize;
789*b1cdbd2cSJim Jagielski sal_Size nPos;
790*b1cdbd2cSJim Jagielski sal_Size nEndOfData;
791*b1cdbd2cSJim Jagielski sal_uInt8* pBuf;
792*b1cdbd2cSJim Jagielski sal_Bool bOwnsData;
793*b1cdbd2cSJim Jagielski
794*b1cdbd2cSJim Jagielski virtual sal_Size GetData( void* pData, sal_Size nSize );
795*b1cdbd2cSJim Jagielski virtual sal_Size PutData( const void* pData, sal_Size nSize );
796*b1cdbd2cSJim Jagielski virtual sal_Size SeekPos( sal_Size nPos );
797*b1cdbd2cSJim Jagielski virtual void SetSize( sal_Size nSize );
798*b1cdbd2cSJim Jagielski virtual void FlushData();
799*b1cdbd2cSJim Jagielski
800*b1cdbd2cSJim Jagielski // AllocateMemory muss folgende Variable mitpflegen:
801*b1cdbd2cSJim Jagielski // - pBuf: Adresse des neuen Blocks
802*b1cdbd2cSJim Jagielski virtual sal_Bool AllocateMemory( sal_Size nSize );
803*b1cdbd2cSJim Jagielski
804*b1cdbd2cSJim Jagielski // ReAllocateMemory muss folgende Variablen mitpflegen:
805*b1cdbd2cSJim Jagielski // - pBuf: Adresse des neuen Blocks
806*b1cdbd2cSJim Jagielski // - nEndOfData: Muss auf nNewSize-1L gesetzt werden, wenn ausserhalb des Blocks
807*b1cdbd2cSJim Jagielski // Muss auf 0 gesetzt werden, wenn neuer Block 0 Byte gross
808*b1cdbd2cSJim Jagielski // - nSize: Neue Groesse des Blocks
809*b1cdbd2cSJim Jagielski // - nPos: Muss auf 0 gesetzt werden, wenn ausserhalb des Blocks
810*b1cdbd2cSJim Jagielski virtual sal_Bool ReAllocateMemory( long nDiff );
811*b1cdbd2cSJim Jagielski
812*b1cdbd2cSJim Jagielski // wird aufgerufen, wenn dem Stream der Speicher gehoert oder wenn
813*b1cdbd2cSJim Jagielski // der Speicher in der Groesse veraendert wird.
814*b1cdbd2cSJim Jagielski // FreeMemory muss folgende Variablen mitpflegen:
815*b1cdbd2cSJim Jagielski // - in abgeleiteten Klassen muessen ggf. Handles genullt werden
816*b1cdbd2cSJim Jagielski virtual void FreeMemory();
817*b1cdbd2cSJim Jagielski
SvMemoryStream(void *)818*b1cdbd2cSJim Jagielski SvMemoryStream(void*) { } // Fuer unsere Subklassen
819*b1cdbd2cSJim Jagielski
820*b1cdbd2cSJim Jagielski public:
821*b1cdbd2cSJim Jagielski SvMemoryStream( void* pBuf, sal_Size nSize, StreamMode eMode);
822*b1cdbd2cSJim Jagielski SvMemoryStream( sal_Size nInitSize=512, sal_Size nResize=64 );
823*b1cdbd2cSJim Jagielski ~SvMemoryStream();
824*b1cdbd2cSJim Jagielski
825*b1cdbd2cSJim Jagielski virtual void ResetError();
826*b1cdbd2cSJim Jagielski
GetEndOfData() const827*b1cdbd2cSJim Jagielski sal_Size GetEndOfData() const { return nEndOfData; }
GetData()828*b1cdbd2cSJim Jagielski const void* GetData() { Flush(); return pBuf; }
829*b1cdbd2cSJim Jagielski operator const void*() { Flush(); return pBuf; }
830*b1cdbd2cSJim Jagielski virtual sal_uInt16 IsA() const;
831*b1cdbd2cSJim Jagielski
832*b1cdbd2cSJim Jagielski void* SwitchBuffer( sal_Size nInitSize=512, sal_Size nResize=64 );
833*b1cdbd2cSJim Jagielski void* SetBuffer( void* pBuf, sal_Size nSize,
834*b1cdbd2cSJim Jagielski sal_Bool bOwnsData=sal_True, sal_Size nEOF=0 );
835*b1cdbd2cSJim Jagielski
ObjectOwnsMemory(sal_Bool bOwn)836*b1cdbd2cSJim Jagielski void ObjectOwnsMemory( sal_Bool bOwn ) { bOwnsData = bOwn; }
IsObjectMemoryOwner()837*b1cdbd2cSJim Jagielski sal_Bool IsObjectMemoryOwner() { return bOwnsData; }
SetResizeOffset(sal_Size nNewResize)838*b1cdbd2cSJim Jagielski void SetResizeOffset( sal_Size nNewResize ) { nResize = nNewResize; }
GetResizeOffset() const839*b1cdbd2cSJim Jagielski sal_Size GetResizeOffset() const { return nResize; }
840*b1cdbd2cSJim Jagielski };
841*b1cdbd2cSJim Jagielski
842*b1cdbd2cSJim Jagielski // --------------------
843*b1cdbd2cSJim Jagielski // - SvDataCopyStream -
844*b1cdbd2cSJim Jagielski // --------------------
845*b1cdbd2cSJim Jagielski
846*b1cdbd2cSJim Jagielski // AB 10.5.1996: Diese Klasse bildet die Basis fuer Klassen, die mittels
847*b1cdbd2cSJim Jagielski // SvData (SO2\DTRANS.HXX/CXX) transportiert werden sollen, z.B. Graphik
848*b1cdbd2cSJim Jagielski // Die abgeleiteten Klassen muessen die virtuellen Funktionen ueberladen.
849*b1cdbd2cSJim Jagielski
850*b1cdbd2cSJim Jagielski class TOOLS_DLLPUBLIC SvDataCopyStream
851*b1cdbd2cSJim Jagielski {
852*b1cdbd2cSJim Jagielski public:
853*b1cdbd2cSJim Jagielski /*-----------------MM 30.04.96 11:01-----------------
854*b1cdbd2cSJim Jagielski mehrfaches Aufrufen von Load und Assign erlaubt
855*b1cdbd2cSJim Jagielski --------------------------------------------------*/
856*b1cdbd2cSJim Jagielski TYPEINFO();
~SvDataCopyStream()857*b1cdbd2cSJim Jagielski virtual ~SvDataCopyStream(){}
858*b1cdbd2cSJim Jagielski virtual void Load( SvStream & ) = 0;
859*b1cdbd2cSJim Jagielski virtual void Save( SvStream & ) = 0;
860*b1cdbd2cSJim Jagielski virtual void Assign( const SvDataCopyStream & );
861*b1cdbd2cSJim Jagielski };
862*b1cdbd2cSJim Jagielski
863*b1cdbd2cSJim Jagielski #endif // _STREAM_HXX
864