]>
Commit | Line | Data |
---|---|---|
3d4c6a21 | 1 | ///////////////////////////////////////////////////////////////////////////// |
49e399d8 | 2 | // Name: src/common/stream.cpp |
3d4c6a21 GL |
3 | // Purpose: wxStream base classes |
4 | // Author: Guilhem Lavaux | |
49e399d8 VZ |
5 | // Modified by: VZ (23.11.00) to fix realloc()ing new[]ed memory, |
6 | // general code review | |
3d4c6a21 GL |
7 | // Created: 11/07/98 |
8 | // RCS-ID: $Id$ | |
9 | // Copyright: (c) Guilhem Lavaux | |
65571936 | 10 | // Licence: wxWindows licence |
3d4c6a21 GL |
11 | ///////////////////////////////////////////////////////////////////////////// |
12 | ||
49e399d8 VZ |
13 | // ============================================================================ |
14 | // declarations | |
15 | // ============================================================================ | |
16 | ||
17 | // ---------------------------------------------------------------------------- | |
18 | // headers | |
19 | // ---------------------------------------------------------------------------- | |
47fc03d2 | 20 | |
db138a4c JS |
21 | // For compilers that support precompilation, includes "wx.h". |
22 | #include "wx/wxprec.h" | |
ce4169a4 RR |
23 | |
24 | #ifdef __BORLANDC__ | |
8898456d | 25 | #pragma hdrstop |
ce4169a4 RR |
26 | #endif |
27 | ||
8898456d WS |
28 | #if wxUSE_STREAMS |
29 | ||
530ecef0 WS |
30 | #include "wx/stream.h" |
31 | ||
ce4169a4 | 32 | #ifndef WX_PRECOMP |
8898456d | 33 | #include "wx/log.h" |
ce4169a4 RR |
34 | #endif |
35 | ||
6d44bf31 | 36 | #include <ctype.h> |
3096bd2f | 37 | #include "wx/datstrm.h" |
733b8ed3 | 38 | #include "wx/textfile.h" |
db138a4c | 39 | |
49e399d8 VZ |
40 | // ---------------------------------------------------------------------------- |
41 | // constants | |
42 | // ---------------------------------------------------------------------------- | |
43 | ||
44 | // the temporary buffer size used when copying from stream to stream | |
2b5f62a0 | 45 | #define BUF_TEMP_SIZE 4096 |
8ef6a930 | 46 | |
49e399d8 VZ |
47 | // ============================================================================ |
48 | // implementation | |
49 | // ============================================================================ | |
50 | ||
6d44bf31 GL |
51 | // ---------------------------------------------------------------------------- |
52 | // wxStreamBuffer | |
53 | // ---------------------------------------------------------------------------- | |
54 | ||
49e399d8 VZ |
55 | void wxStreamBuffer::SetError(wxStreamError err) |
56 | { | |
2b5f62a0 | 57 | if ( m_stream && m_stream->m_lasterror == wxSTREAM_NO_ERROR ) |
49e399d8 VZ |
58 | m_stream->m_lasterror = err; |
59 | } | |
60 | ||
61 | void wxStreamBuffer::InitBuffer() | |
62 | { | |
63 | m_buffer_start = | |
64 | m_buffer_end = | |
65 | m_buffer_pos = NULL; | |
49e399d8 | 66 | |
d4b45f48 | 67 | // if we are going to allocate the buffer, we should free it later as well |
d775fa82 | 68 | m_destroybuf = true; |
49e399d8 VZ |
69 | } |
70 | ||
71 | void wxStreamBuffer::Init() | |
72 | { | |
73 | InitBuffer(); | |
74 | ||
d775fa82 | 75 | m_fixed = true; |
49e399d8 | 76 | } |
926c550d | 77 | |
f42c1512 | 78 | void wxStreamBuffer::InitWithStream(wxStreamBase& stream, BufMode mode) |
6d44bf31 | 79 | { |
a2bd1fbb VZ |
80 | Init(); |
81 | ||
f42c1512 | 82 | m_stream = &stream; |
49e399d8 VZ |
83 | m_mode = mode; |
84 | ||
f42c1512 | 85 | m_flushable = true; |
6d44bf31 GL |
86 | } |
87 | ||
f42c1512 | 88 | wxStreamBuffer::wxStreamBuffer(BufMode mode) |
84b46c35 | 89 | { |
a2bd1fbb VZ |
90 | Init(); |
91 | ||
f42c1512 | 92 | m_stream = NULL; |
49e399d8 VZ |
93 | m_mode = mode; |
94 | ||
f42c1512 | 95 | m_flushable = false; |
84b46c35 GL |
96 | } |
97 | ||
98 | wxStreamBuffer::wxStreamBuffer(const wxStreamBuffer& buffer) | |
99 | { | |
2b5f62a0 | 100 | // doing this has big chances to lead to a crash when the source buffer is |
49e399d8 | 101 | // destroyed (otherwise assume the caller knows what he does) |
2b5f62a0 | 102 | wxASSERT_MSG( !buffer.m_destroybuf, |
9a83f860 | 103 | wxT("it's a bad idea to copy this buffer") ); |
49e399d8 VZ |
104 | |
105 | m_buffer_start = buffer.m_buffer_start; | |
106 | m_buffer_end = buffer.m_buffer_end; | |
107 | m_buffer_pos = buffer.m_buffer_pos; | |
49e399d8 VZ |
108 | m_fixed = buffer.m_fixed; |
109 | m_flushable = buffer.m_flushable; | |
110 | m_stream = buffer.m_stream; | |
111 | m_mode = buffer.m_mode; | |
d775fa82 | 112 | m_destroybuf = false; |
84b46c35 GL |
113 | } |
114 | ||
49e399d8 | 115 | void wxStreamBuffer::FreeBuffer() |
6d44bf31 | 116 | { |
49e399d8 | 117 | if ( m_destroybuf ) |
0d2ef7a8 | 118 | { |
49e399d8 | 119 | free(m_buffer_start); |
0d2ef7a8 VZ |
120 | m_buffer_start = NULL; |
121 | } | |
6d44bf31 GL |
122 | } |
123 | ||
49e399d8 | 124 | wxStreamBuffer::~wxStreamBuffer() |
6d44bf31 | 125 | { |
49e399d8 | 126 | FreeBuffer(); |
6d44bf31 GL |
127 | } |
128 | ||
47fc03d2 VZ |
129 | wxInputStream *wxStreamBuffer::GetInputStream() const |
130 | { | |
131 | return m_mode == write ? NULL : (wxInputStream *)m_stream; | |
132 | } | |
133 | ||
134 | wxOutputStream *wxStreamBuffer::GetOutputStream() const | |
135 | { | |
136 | return m_mode == read ? NULL : (wxOutputStream *)m_stream; | |
137 | } | |
138 | ||
49e399d8 VZ |
139 | void wxStreamBuffer::SetBufferIO(void *buffer_start, |
140 | void *buffer_end, | |
141 | bool takeOwnership) | |
67c8c225 VZ |
142 | { |
143 | SetBufferIO(buffer_start, (char *)buffer_end - (char *)buffer_start, | |
144 | takeOwnership); | |
145 | } | |
146 | ||
147 | void wxStreamBuffer::SetBufferIO(void *start, | |
148 | size_t len, | |
149 | bool takeOwnership) | |
6d44bf31 | 150 | { |
49e399d8 VZ |
151 | // start by freeing the old buffer |
152 | FreeBuffer(); | |
885ee235 | 153 | |
67c8c225 VZ |
154 | m_buffer_start = (char *)start; |
155 | m_buffer_end = m_buffer_start + len; | |
6d44bf31 | 156 | |
49e399d8 | 157 | // if we own it, we free it |
421db2ad | 158 | m_destroybuf = takeOwnership; |
49e399d8 VZ |
159 | |
160 | ResetBuffer(); | |
161 | } | |
6d44bf31 | 162 | |
49e399d8 VZ |
163 | void wxStreamBuffer::SetBufferIO(size_t bufsize) |
164 | { | |
49e399d8 VZ |
165 | if ( bufsize ) |
166 | { | |
0d2ef7a8 | 167 | // this will free the old buffer and allocate the new one |
d775fa82 | 168 | SetBufferIO(malloc(bufsize), bufsize, true /* take ownership */); |
49e399d8 VZ |
169 | } |
170 | else // no buffer size => no buffer | |
171 | { | |
0d2ef7a8 VZ |
172 | // still free the old one |
173 | FreeBuffer(); | |
49e399d8 VZ |
174 | InitBuffer(); |
175 | } | |
6d44bf31 GL |
176 | } |
177 | ||
178 | void wxStreamBuffer::ResetBuffer() | |
179 | { | |
2b5f62a0 VZ |
180 | if ( m_stream ) |
181 | { | |
182 | m_stream->Reset(); | |
183 | m_stream->m_lastcount = 0; | |
184 | } | |
49e399d8 | 185 | |
2b5f62a0 VZ |
186 | m_buffer_pos = m_mode == read && m_flushable |
187 | ? m_buffer_end | |
188 | : m_buffer_start; | |
6d44bf31 GL |
189 | } |
190 | ||
df18cc7a VZ |
191 | void wxStreamBuffer::Truncate() |
192 | { | |
193 | size_t new_size = m_buffer_pos - m_buffer_start; | |
b23bc769 | 194 | if ( m_buffer_pos == m_buffer_end ) |
df18cc7a VZ |
195 | return; |
196 | ||
197 | if ( !new_size ) | |
198 | { | |
199 | FreeBuffer(); | |
200 | InitBuffer(); | |
201 | return; | |
202 | } | |
203 | ||
204 | char *new_start = (char *)realloc(m_buffer_start, new_size); | |
9a83f860 | 205 | wxCHECK_RET( new_size, wxT("shrinking buffer shouldn't fail") ); |
df18cc7a VZ |
206 | |
207 | m_buffer_start = new_start; | |
b23bc769 | 208 | m_buffer_end = m_buffer_start + new_size; |
df18cc7a VZ |
209 | m_buffer_pos = m_buffer_end; |
210 | } | |
211 | ||
49e399d8 | 212 | // fill the buffer with as much data as possible (only for read buffers) |
75ed1d15 GL |
213 | bool wxStreamBuffer::FillBuffer() |
214 | { | |
47fc03d2 VZ |
215 | wxInputStream *inStream = GetInputStream(); |
216 | ||
d775fa82 | 217 | // It's legal to have no stream, so we don't complain about it just return false |
2b5f62a0 | 218 | if ( !inStream ) |
d775fa82 | 219 | return false; |
75ed1d15 | 220 | |
b23bc769 | 221 | size_t count = inStream->OnSysRead(GetBufferStart(), GetBufferSize()); |
49e399d8 | 222 | if ( !count ) |
d775fa82 | 223 | return false; |
75ed1d15 | 224 | |
49e399d8 VZ |
225 | m_buffer_end = m_buffer_start + count; |
226 | m_buffer_pos = m_buffer_start; | |
227 | ||
d775fa82 | 228 | return true; |
75ed1d15 GL |
229 | } |
230 | ||
49e399d8 | 231 | // write the buffer contents to the stream (only for write buffers) |
75ed1d15 GL |
232 | bool wxStreamBuffer::FlushBuffer() |
233 | { | |
9a83f860 | 234 | wxCHECK_MSG( m_flushable, false, wxT("can't flush this buffer") ); |
75ed1d15 | 235 | |
49e399d8 VZ |
236 | // FIXME: what is this check for? (VZ) |
237 | if ( m_buffer_pos == m_buffer_start ) | |
d775fa82 | 238 | return false; |
75ed1d15 | 239 | |
47fc03d2 VZ |
240 | wxOutputStream *outStream = GetOutputStream(); |
241 | ||
9a83f860 | 242 | wxCHECK_MSG( outStream, false, wxT("should have a stream in wxStreamBuffer") ); |
49e399d8 VZ |
243 | |
244 | size_t current = m_buffer_pos - m_buffer_start; | |
47fc03d2 | 245 | size_t count = outStream->OnSysWrite(m_buffer_start, current); |
49e399d8 | 246 | if ( count != current ) |
d775fa82 | 247 | return false; |
49e399d8 VZ |
248 | |
249 | m_buffer_pos = m_buffer_start; | |
75ed1d15 | 250 | |
d775fa82 | 251 | return true; |
75ed1d15 GL |
252 | } |
253 | ||
49e399d8 VZ |
254 | size_t wxStreamBuffer::GetDataLeft() |
255 | { | |
256 | /* Why is this done? RR. */ | |
257 | if ( m_buffer_pos == m_buffer_end && m_flushable) | |
258 | FillBuffer(); | |
259 | ||
260 | return GetBytesLeft(); | |
261 | } | |
262 | ||
263 | // copy up to size bytes from our buffer into the provided one | |
75ed1d15 GL |
264 | void wxStreamBuffer::GetFromBuffer(void *buffer, size_t size) |
265 | { | |
49e399d8 VZ |
266 | // don't get more bytes than left in the buffer |
267 | size_t left = GetBytesLeft(); | |
75ed1d15 | 268 | |
49e399d8 VZ |
269 | if ( size > left ) |
270 | size = left; | |
75ed1d15 | 271 | |
49e399d8 VZ |
272 | memcpy(buffer, m_buffer_pos, size); |
273 | m_buffer_pos += size; | |
75ed1d15 GL |
274 | } |
275 | ||
49e399d8 | 276 | // copy the contents of the provided buffer into this one |
75ed1d15 GL |
277 | void wxStreamBuffer::PutToBuffer(const void *buffer, size_t size) |
278 | { | |
49e399d8 | 279 | size_t left = GetBytesLeft(); |
2b5f62a0 | 280 | |
49e399d8 VZ |
281 | if ( size > left ) |
282 | { | |
283 | if ( m_fixed ) | |
284 | { | |
285 | // we can't realloc the buffer, so just copy what we can | |
286 | size = left; | |
287 | } | |
288 | else // !m_fixed | |
289 | { | |
290 | // realloc the buffer to have enough space for the data | |
b23bc769 | 291 | if ( m_buffer_pos + size > m_buffer_end ) |
49e399d8 | 292 | { |
b23bc769 VZ |
293 | size_t delta = m_buffer_pos - m_buffer_start; |
294 | size_t new_size = delta + size; | |
295 | ||
296 | char *startOld = m_buffer_start; | |
297 | m_buffer_start = (char *)realloc(m_buffer_start, new_size); | |
298 | if ( !m_buffer_start ) | |
299 | { | |
300 | // don't leak memory if realloc() failed | |
301 | m_buffer_start = startOld; | |
302 | ||
303 | // what else can we do? | |
304 | return; | |
305 | } | |
306 | ||
307 | // adjust the pointers invalidated by realloc() | |
308 | m_buffer_pos = m_buffer_start + delta; | |
309 | m_buffer_end = m_buffer_start + new_size; | |
310 | } // else: the buffer is big enough | |
49e399d8 | 311 | } |
56dc1ffd | 312 | } |
49e399d8 VZ |
313 | |
314 | memcpy(m_buffer_pos, buffer, size); | |
315 | m_buffer_pos += size; | |
75ed1d15 GL |
316 | } |
317 | ||
84b46c35 GL |
318 | void wxStreamBuffer::PutChar(char c) |
319 | { | |
47fc03d2 VZ |
320 | wxOutputStream *outStream = GetOutputStream(); |
321 | ||
9a83f860 | 322 | wxCHECK_RET( outStream, wxT("should have a stream in wxStreamBuffer") ); |
84b46c35 | 323 | |
49e399d8 VZ |
324 | // if we don't have buffer at all, just forward this call to the stream, |
325 | if ( !HasBuffer() ) | |
326 | { | |
2b5f62a0 | 327 | outStream->OnSysWrite(&c, sizeof(c)); |
49e399d8 VZ |
328 | } |
329 | else | |
330 | { | |
331 | // otherwise check we have enough space left | |
332 | if ( !GetDataLeft() && !FlushBuffer() ) | |
333 | { | |
334 | // we don't | |
2b5f62a0 | 335 | SetError(wxSTREAM_WRITE_ERROR); |
49e399d8 VZ |
336 | } |
337 | else | |
338 | { | |
2b5f62a0 | 339 | PutToBuffer(&c, sizeof(c)); |
49e399d8 VZ |
340 | m_stream->m_lastcount = 1; |
341 | } | |
342 | } | |
84b46c35 GL |
343 | } |
344 | ||
6319afe3 GL |
345 | char wxStreamBuffer::Peek() |
346 | { | |
49e399d8 | 347 | wxCHECK_MSG( m_stream && HasBuffer(), 0, |
9a83f860 | 348 | wxT("should have the stream and the buffer in wxStreamBuffer") ); |
6319afe3 | 349 | |
49e399d8 VZ |
350 | if ( !GetDataLeft() ) |
351 | { | |
2b5f62a0 | 352 | SetError(wxSTREAM_READ_ERROR); |
49e399d8 VZ |
353 | return 0; |
354 | } | |
6319afe3 | 355 | |
49e399d8 | 356 | char c; |
2b5f62a0 | 357 | GetFromBuffer(&c, sizeof(c)); |
49e399d8 | 358 | m_buffer_pos--; |
6319afe3 | 359 | |
49e399d8 | 360 | return c; |
6319afe3 GL |
361 | } |
362 | ||
84b46c35 GL |
363 | char wxStreamBuffer::GetChar() |
364 | { | |
47fc03d2 VZ |
365 | wxInputStream *inStream = GetInputStream(); |
366 | ||
9a83f860 | 367 | wxCHECK_MSG( inStream, 0, wxT("should have a stream in wxStreamBuffer") ); |
84b46c35 | 368 | |
49e399d8 VZ |
369 | char c; |
370 | if ( !HasBuffer() ) | |
371 | { | |
2b5f62a0 | 372 | inStream->OnSysRead(&c, sizeof(c)); |
49e399d8 VZ |
373 | } |
374 | else | |
375 | { | |
376 | if ( !GetDataLeft() ) | |
377 | { | |
2b5f62a0 | 378 | SetError(wxSTREAM_READ_ERROR); |
49e399d8 VZ |
379 | c = 0; |
380 | } | |
381 | else | |
382 | { | |
2b5f62a0 | 383 | GetFromBuffer(&c, sizeof(c)); |
49e399d8 VZ |
384 | m_stream->m_lastcount = 1; |
385 | } | |
386 | } | |
84b46c35 | 387 | |
84b46c35 | 388 | return c; |
84b46c35 GL |
389 | } |
390 | ||
8ef6a930 | 391 | size_t wxStreamBuffer::Read(void *buffer, size_t size) |
6d44bf31 | 392 | { |
9a83f860 | 393 | wxASSERT_MSG( buffer, wxT("Warning: Null pointer is about to be used") ); |
8913c40c RR |
394 | |
395 | /* Clear buffer first */ | |
396 | memset(buffer, 0x00, size); | |
397 | ||
49e399d8 | 398 | // lasterror is reset before all new IO calls |
2b5f62a0 VZ |
399 | if ( m_stream ) |
400 | m_stream->Reset(); | |
49e399d8 | 401 | |
15dc68b6 | 402 | size_t readBytes; |
49e399d8 VZ |
403 | if ( !HasBuffer() ) |
404 | { | |
2b5f62a0 VZ |
405 | wxInputStream *inStream = GetInputStream(); |
406 | ||
9a83f860 | 407 | wxCHECK_MSG( inStream, 0, wxT("should have a stream in wxStreamBuffer") ); |
2b5f62a0 | 408 | |
15dc68b6 | 409 | readBytes = inStream->OnSysRead(buffer, size); |
49e399d8 VZ |
410 | } |
411 | else // we have a buffer, use it | |
412 | { | |
413 | size_t orig_size = size; | |
414 | ||
415 | while ( size > 0 ) | |
416 | { | |
417 | size_t left = GetDataLeft(); | |
418 | ||
419 | // if the requested number of bytes if greater than the buffer | |
420 | // size, read data in chunks | |
421 | if ( size > left ) | |
422 | { | |
423 | GetFromBuffer(buffer, left); | |
424 | size -= left; | |
425 | buffer = (char *)buffer + left; | |
426 | ||
427 | if ( !FillBuffer() ) | |
428 | { | |
2b5f62a0 | 429 | SetError(wxSTREAM_EOF); |
49e399d8 VZ |
430 | break; |
431 | } | |
432 | } | |
433 | else // otherwise just do it in one gulp | |
434 | { | |
435 | GetFromBuffer(buffer, size); | |
436 | size = 0; | |
437 | } | |
438 | } | |
439 | ||
15dc68b6 | 440 | readBytes = orig_size - size; |
6d44bf31 | 441 | } |
49e399d8 | 442 | |
2b5f62a0 | 443 | if ( m_stream ) |
15dc68b6 | 444 | m_stream->m_lastcount = readBytes; |
2b5f62a0 | 445 | |
15dc68b6 | 446 | return readBytes; |
6d44bf31 GL |
447 | } |
448 | ||
49e399d8 VZ |
449 | // this should really be called "Copy()" |
450 | size_t wxStreamBuffer::Read(wxStreamBuffer *dbuf) | |
8ef6a930 | 451 | { |
9a83f860 | 452 | wxCHECK_MSG( m_mode != write, 0, wxT("can't read from this buffer") ); |
8ef6a930 | 453 | |
49e399d8 VZ |
454 | char buf[BUF_TEMP_SIZE]; |
455 | size_t nRead, | |
456 | total = 0; | |
7f42cff1 | 457 | |
49e399d8 VZ |
458 | do |
459 | { | |
c15b71ae | 460 | nRead = Read(buf, WXSIZEOF(buf)); |
49e399d8 VZ |
461 | if ( nRead ) |
462 | { | |
463 | nRead = dbuf->Write(buf, nRead); | |
464 | total += nRead; | |
465 | } | |
466 | } | |
467 | while ( nRead ); | |
468 | ||
469 | return total; | |
8ef6a930 GL |
470 | } |
471 | ||
472 | size_t wxStreamBuffer::Write(const void *buffer, size_t size) | |
6d44bf31 | 473 | { |
9a83f860 | 474 | wxASSERT_MSG( buffer, wxT("Warning: Null pointer is about to be send") ); |
8913c40c | 475 | |
2b5f62a0 VZ |
476 | if (m_stream) |
477 | { | |
478 | // lasterror is reset before all new IO calls | |
479 | m_stream->Reset(); | |
480 | } | |
6d44bf31 | 481 | |
999836aa | 482 | size_t ret; |
6d44bf31 | 483 | |
49e399d8 VZ |
484 | if ( !HasBuffer() && m_fixed ) |
485 | { | |
2b5f62a0 VZ |
486 | wxOutputStream *outStream = GetOutputStream(); |
487 | ||
9a83f860 | 488 | wxCHECK_MSG( outStream, 0, wxT("should have a stream in wxStreamBuffer") ); |
2b5f62a0 | 489 | |
49e399d8 | 490 | // no buffer, just forward the call to the stream |
2b5f62a0 | 491 | ret = outStream->OnSysWrite(buffer, size); |
49e399d8 VZ |
492 | } |
493 | else // we [may] have a buffer, use it | |
494 | { | |
495 | size_t orig_size = size; | |
496 | ||
497 | while ( size > 0 ) | |
498 | { | |
499 | size_t left = GetBytesLeft(); | |
500 | ||
501 | // if the buffer is too large to fit in the stream buffer, split | |
502 | // it in smaller parts | |
503 | // | |
504 | // NB: If stream buffer isn't fixed (as for wxMemoryOutputStream), | |
505 | // we always go to the second case. | |
506 | // | |
507 | // FIXME: fine, but if it fails we should (re)try writing it by | |
508 | // chunks as this will (hopefully) always work (VZ) | |
2b5f62a0 | 509 | |
49e399d8 VZ |
510 | if ( size > left && m_fixed ) |
511 | { | |
512 | PutToBuffer(buffer, left); | |
513 | size -= left; | |
514 | buffer = (char *)buffer + left; | |
515 | ||
516 | if ( !FlushBuffer() ) | |
517 | { | |
2b5f62a0 | 518 | SetError(wxSTREAM_WRITE_ERROR); |
49e399d8 VZ |
519 | |
520 | break; | |
521 | } | |
522 | ||
523 | m_buffer_pos = m_buffer_start; | |
524 | } | |
525 | else // we can do it in one gulp | |
526 | { | |
527 | PutToBuffer(buffer, size); | |
528 | size = 0; | |
529 | } | |
530 | } | |
531 | ||
2b5f62a0 | 532 | ret = orig_size - size; |
6d44bf31 | 533 | } |
49e399d8 | 534 | |
2b5f62a0 VZ |
535 | if (m_stream) |
536 | { | |
537 | // i am not entirely sure what we do this for | |
538 | m_stream->m_lastcount = ret; | |
539 | } | |
540 | ||
541 | return ret; | |
8ef6a930 GL |
542 | } |
543 | ||
544 | size_t wxStreamBuffer::Write(wxStreamBuffer *sbuf) | |
545 | { | |
9a83f860 VZ |
546 | wxCHECK_MSG( m_mode != read, 0, wxT("can't write to this buffer") ); |
547 | wxCHECK_MSG( sbuf->m_mode != write, 0, wxT("can't read from that buffer") ); | |
8ef6a930 | 548 | |
49e399d8 VZ |
549 | char buf[BUF_TEMP_SIZE]; |
550 | size_t nWrite, | |
551 | total = 0; | |
7f42cff1 | 552 | |
49e399d8 VZ |
553 | do |
554 | { | |
555 | size_t nRead = sbuf->Read(buf, WXSIZEOF(buf)); | |
556 | if ( nRead ) | |
557 | { | |
558 | nWrite = Write(buf, nRead); | |
559 | if ( nWrite < nRead ) | |
560 | { | |
561 | // put back data we couldn't copy | |
562 | wxInputStream *in_stream = (wxInputStream *)sbuf->GetStream(); | |
563 | ||
564 | in_stream->Ungetch(buf + nWrite, nRead - nWrite); | |
565 | } | |
566 | ||
567 | total += nWrite; | |
568 | } | |
569 | else | |
570 | { | |
571 | nWrite = 0; | |
572 | } | |
573 | } | |
574 | while ( nWrite == WXSIZEOF(buf) ); | |
fae05df5 | 575 | |
49e399d8 | 576 | return total; |
75ed1d15 GL |
577 | } |
578 | ||
4004775e | 579 | wxFileOffset wxStreamBuffer::Seek(wxFileOffset pos, wxSeekMode mode) |
75ed1d15 | 580 | { |
4004775e | 581 | wxFileOffset ret_off, diff; |
75ed1d15 | 582 | |
4004775e | 583 | wxFileOffset last_access = GetLastAccess(); |
75ed1d15 | 584 | |
49e399d8 VZ |
585 | if ( !m_flushable ) |
586 | { | |
587 | switch (mode) | |
588 | { | |
589 | case wxFromStart: | |
590 | diff = pos; | |
591 | break; | |
592 | ||
593 | case wxFromCurrent: | |
594 | diff = pos + GetIntPosition(); | |
595 | break; | |
596 | ||
597 | case wxFromEnd: | |
598 | diff = pos + last_access; | |
599 | break; | |
600 | ||
601 | default: | |
9a83f860 | 602 | wxFAIL_MSG( wxT("invalid seek mode") ); |
49e399d8 | 603 | |
30984dea | 604 | return wxInvalidOffset; |
49e399d8 VZ |
605 | } |
606 | if (diff < 0 || diff > last_access) | |
30984dea | 607 | return wxInvalidOffset; |
17a1ebd1 | 608 | size_t int_diff = wx_truncate_cast(size_t, diff); |
287d71d9 WS |
609 | wxCHECK_MSG( (wxFileOffset)int_diff == diff, wxInvalidOffset, wxT("huge file not supported") ); |
610 | SetIntPosition(int_diff); | |
49e399d8 | 611 | return diff; |
d984207c | 612 | } |
49e399d8 VZ |
613 | |
614 | switch ( mode ) | |
615 | { | |
616 | case wxFromStart: | |
617 | // We'll try to compute an internal position later ... | |
618 | ret_off = m_stream->OnSysSeek(pos, wxFromStart); | |
619 | ResetBuffer(); | |
620 | return ret_off; | |
621 | ||
622 | case wxFromCurrent: | |
623 | diff = pos + GetIntPosition(); | |
624 | ||
625 | if ( (diff > last_access) || (diff < 0) ) | |
626 | { | |
627 | // We must take into account the fact that we have read | |
628 | // something previously. | |
629 | ret_off = m_stream->OnSysSeek(diff-last_access, wxFromCurrent); | |
630 | ResetBuffer(); | |
631 | return ret_off; | |
632 | } | |
633 | else | |
634 | { | |
17a1ebd1 | 635 | size_t int_diff = wx_truncate_cast(size_t, diff); |
287d71d9 WS |
636 | wxCHECK_MSG( (wxFileOffset)int_diff == diff, wxInvalidOffset, wxT("huge file not supported") ); |
637 | SetIntPosition(int_diff); | |
c81b7d7d | 638 | return diff; |
49e399d8 VZ |
639 | } |
640 | ||
641 | case wxFromEnd: | |
642 | // Hard to compute: always seek to the requested position. | |
643 | ret_off = m_stream->OnSysSeek(pos, wxFromEnd); | |
644 | ResetBuffer(); | |
645 | return ret_off; | |
75ed1d15 | 646 | } |
49e399d8 | 647 | |
30984dea | 648 | return wxInvalidOffset; |
75ed1d15 GL |
649 | } |
650 | ||
4004775e | 651 | wxFileOffset wxStreamBuffer::Tell() const |
75ed1d15 | 652 | { |
30984dea | 653 | wxFileOffset pos; |
915a955c | 654 | |
2b5f62a0 VZ |
655 | // ask the stream for position if we have a real one |
656 | if ( m_stream ) | |
915a955c VZ |
657 | { |
658 | pos = m_stream->OnSysTell(); | |
659 | if ( pos == wxInvalidOffset ) | |
30984dea | 660 | return wxInvalidOffset; |
915a955c VZ |
661 | } |
662 | else // no associated stream | |
663 | { | |
664 | pos = 0; | |
665 | } | |
c7a9fa36 RR |
666 | |
667 | pos += GetIntPosition(); | |
cd6ce4a9 | 668 | |
49e399d8 | 669 | if ( m_mode == read && m_flushable ) |
c7a9fa36 | 670 | pos -= GetLastAccess(); |
cd6ce4a9 | 671 | |
c7a9fa36 | 672 | return pos; |
75ed1d15 GL |
673 | } |
674 | ||
75ed1d15 GL |
675 | // ---------------------------------------------------------------------------- |
676 | // wxStreamBase | |
677 | // ---------------------------------------------------------------------------- | |
678 | ||
6285e36b VZ |
679 | IMPLEMENT_ABSTRACT_CLASS(wxStreamBase, wxObject) |
680 | ||
75ed1d15 GL |
681 | wxStreamBase::wxStreamBase() |
682 | { | |
2b5f62a0 | 683 | m_lasterror = wxSTREAM_NO_ERROR; |
c7a9fa36 | 684 | m_lastcount = 0; |
75ed1d15 GL |
685 | } |
686 | ||
687 | wxStreamBase::~wxStreamBase() | |
688 | { | |
689 | } | |
690 | ||
588066b7 VZ |
691 | size_t wxStreamBase::GetSize() const |
692 | { | |
693 | wxFileOffset length = GetLength(); | |
653752be | 694 | if ( length == (wxFileOffset)wxInvalidOffset ) |
17a1ebd1 VZ |
695 | return 0; |
696 | ||
697 | const size_t len = wx_truncate_cast(size_t, length); | |
9a83f860 | 698 | wxASSERT_MSG( len == length + size_t(0), wxT("large files not supported") ); |
17a1ebd1 VZ |
699 | |
700 | return len; | |
588066b7 VZ |
701 | } |
702 | ||
4004775e | 703 | wxFileOffset wxStreamBase::OnSysSeek(wxFileOffset WXUNUSED(seek), wxSeekMode WXUNUSED(mode)) |
b9138710 | 704 | { |
30984dea | 705 | return wxInvalidOffset; |
b9138710 VZ |
706 | } |
707 | ||
4004775e | 708 | wxFileOffset wxStreamBase::OnSysTell() const |
b9138710 | 709 | { |
30984dea | 710 | return wxInvalidOffset; |
b9138710 VZ |
711 | } |
712 | ||
1678ad78 GL |
713 | // ---------------------------------------------------------------------------- |
714 | // wxInputStream | |
715 | // ---------------------------------------------------------------------------- | |
716 | ||
6285e36b VZ |
717 | IMPLEMENT_ABSTRACT_CLASS(wxInputStream, wxStreamBase) |
718 | ||
3d4c6a21 | 719 | wxInputStream::wxInputStream() |
3d4c6a21 | 720 | { |
49e399d8 VZ |
721 | m_wback = NULL; |
722 | m_wbacksize = | |
723 | m_wbackcur = 0; | |
6d44bf31 GL |
724 | } |
725 | ||
fae05df5 | 726 | wxInputStream::~wxInputStream() |
6d44bf31 | 727 | { |
fae05df5 | 728 | free(m_wback); |
3d4c6a21 GL |
729 | } |
730 | ||
2b5f62a0 | 731 | bool wxInputStream::CanRead() const |
47fc03d2 | 732 | { |
2b5f62a0 VZ |
733 | // we don't know if there is anything to read or not and by default we |
734 | // prefer to be optimistic and try to read data unless we know for sure | |
735 | // there is no more of it | |
736 | return m_lasterror != wxSTREAM_EOF; | |
47fc03d2 VZ |
737 | } |
738 | ||
cd6ce4a9 VZ |
739 | bool wxInputStream::Eof() const |
740 | { | |
2b5f62a0 VZ |
741 | // the only way the base class can know we're at EOF is when we'd already |
742 | // tried to read beyond it in which case last error is set accordingly | |
743 | return GetLastError() == wxSTREAM_EOF; | |
cd6ce4a9 VZ |
744 | } |
745 | ||
fae05df5 | 746 | char *wxInputStream::AllocSpaceWBack(size_t needed_size) |
3d4c6a21 | 747 | { |
49e399d8 | 748 | // get number of bytes left from previous wback buffer |
c7a9fa36 | 749 | size_t toget = m_wbacksize - m_wbackcur; |
fae05df5 | 750 | |
49e399d8 VZ |
751 | // allocate a buffer large enough to hold prev + new data |
752 | char *temp_b = (char *)malloc(needed_size + toget); | |
fae05df5 | 753 | |
c7a9fa36 RR |
754 | if (!temp_b) |
755 | return NULL; | |
fae05df5 | 756 | |
adc35078 | 757 | // copy previous data (and free old buffer) if needed |
c7a9fa36 RR |
758 | if (m_wback) |
759 | { | |
760 | memmove(temp_b + needed_size, m_wback + m_wbackcur, toget); | |
761 | free(m_wback); | |
762 | } | |
5ac8158a | 763 | |
adc35078 | 764 | // done |
c7a9fa36 RR |
765 | m_wback = temp_b; |
766 | m_wbackcur = 0; | |
767 | m_wbacksize = needed_size + toget; | |
783ff666 | 768 | |
49e399d8 | 769 | return m_wback; |
6d44bf31 GL |
770 | } |
771 | ||
2b5f62a0 | 772 | size_t wxInputStream::GetWBack(void *buf, size_t size) |
6d44bf31 | 773 | { |
9a83f860 | 774 | wxASSERT_MSG( buf, wxT("Warning: Null pointer is about to be used") ); |
8913c40c RR |
775 | |
776 | /* Clear buffer first */ | |
777 | memset(buf, 0x00, size); | |
778 | ||
c7a9fa36 RR |
779 | if (!m_wback) |
780 | return 0; | |
a324a7bc | 781 | |
e9f69291 VZ |
782 | // how many bytes do we have in the buffer? |
783 | size_t toget = m_wbacksize - m_wbackcur; | |
784 | ||
2b5f62a0 | 785 | if ( size < toget ) |
e9f69291 VZ |
786 | { |
787 | // we won't read everything | |
2b5f62a0 | 788 | toget = size; |
e9f69291 | 789 | } |
fae05df5 | 790 | |
2b5f62a0 | 791 | // copy the data from the cache |
e9f69291 | 792 | memcpy(buf, m_wback + m_wbackcur, toget); |
fae05df5 | 793 | |
49e399d8 | 794 | m_wbackcur += toget; |
e9f69291 | 795 | if ( m_wbackcur == m_wbacksize ) |
c7a9fa36 | 796 | { |
e9f69291 | 797 | // TODO: should we really free it here all the time? maybe keep it? |
c7a9fa36 | 798 | free(m_wback); |
49e399d8 | 799 | m_wback = NULL; |
c7a9fa36 RR |
800 | m_wbacksize = 0; |
801 | m_wbackcur = 0; | |
802 | } | |
cd6ce4a9 | 803 | |
e9f69291 | 804 | // return the number of bytes copied |
49e399d8 | 805 | return toget; |
6d44bf31 GL |
806 | } |
807 | ||
8f7173ab | 808 | size_t wxInputStream::Ungetch(const void *buf, size_t bufsize) |
fae05df5 | 809 | { |
9a83f860 | 810 | wxASSERT_MSG( buf, wxT("Warning: Null pointer is about to be used in Ungetch()") ); |
8913c40c | 811 | |
42a3aedb VZ |
812 | if ( m_lasterror != wxSTREAM_NO_ERROR && m_lasterror != wxSTREAM_EOF ) |
813 | { | |
814 | // can't operate on this stream until the error is cleared | |
815 | return 0; | |
816 | } | |
817 | ||
c7a9fa36 RR |
818 | char *ptrback = AllocSpaceWBack(bufsize); |
819 | if (!ptrback) | |
820 | return 0; | |
cd6ce4a9 | 821 | |
d775fa82 | 822 | // Eof() shouldn't return true any longer |
42a3aedb VZ |
823 | if ( m_lasterror == wxSTREAM_EOF ) |
824 | m_lasterror = wxSTREAM_NO_ERROR; | |
825 | ||
c7a9fa36 RR |
826 | memcpy(ptrback, buf, bufsize); |
827 | return bufsize; | |
fae05df5 GL |
828 | } |
829 | ||
830 | bool wxInputStream::Ungetch(char c) | |
1e3eca9d | 831 | { |
2b5f62a0 | 832 | return Ungetch(&c, sizeof(c)) != 0; |
fae05df5 GL |
833 | } |
834 | ||
6ea48c51 | 835 | int wxInputStream::GetC() |
fae05df5 | 836 | { |
6ea48c51 | 837 | unsigned char c; |
2b5f62a0 | 838 | Read(&c, sizeof(c)); |
6ea48c51 | 839 | return LastRead() ? c : wxEOF; |
1e3eca9d GL |
840 | } |
841 | ||
49e399d8 | 842 | wxInputStream& wxInputStream::Read(void *buf, size_t size) |
6d44bf31 | 843 | { |
9a83f860 | 844 | wxASSERT_MSG( buf, wxT("Warning: Null pointer is about to be read") ); |
8913c40c | 845 | |
9a76510b VZ |
846 | char *p = (char *)buf; |
847 | m_lastcount = 0; | |
848 | ||
849 | size_t read = GetWBack(buf, size); | |
850 | for ( ;; ) | |
c7a9fa36 | 851 | { |
9a76510b VZ |
852 | size -= read; |
853 | m_lastcount += read; | |
854 | p += read; | |
855 | ||
856 | if ( !size ) | |
857 | { | |
858 | // we read the requested amount of data | |
859 | break; | |
860 | } | |
861 | ||
2b5f62a0 VZ |
862 | if ( p != buf && !CanRead() ) |
863 | { | |
864 | // we have already read something and we would block in OnSysRead() | |
865 | // now: don't do it but return immediately | |
866 | break; | |
867 | } | |
868 | ||
9b11cb6e | 869 | read = OnSysRead(p, size); |
9a76510b VZ |
870 | if ( !read ) |
871 | { | |
872 | // no more data available | |
873 | break; | |
874 | } | |
c7a9fa36 | 875 | } |
fae05df5 | 876 | |
c7a9fa36 | 877 | return *this; |
3d4c6a21 GL |
878 | } |
879 | ||
75ed1d15 GL |
880 | char wxInputStream::Peek() |
881 | { | |
c7a9fa36 | 882 | char c; |
2b5f62a0 VZ |
883 | Read(&c, sizeof(c)); |
884 | if (m_lasterror == wxSTREAM_NO_ERROR) | |
c7a9fa36 RR |
885 | { |
886 | Ungetch(c); | |
887 | return c; | |
888 | } | |
cd6ce4a9 | 889 | |
c7a9fa36 | 890 | return 0; |
75ed1d15 GL |
891 | } |
892 | ||
3d4c6a21 GL |
893 | wxInputStream& wxInputStream::Read(wxOutputStream& stream_out) |
894 | { | |
68f14620 | 895 | size_t lastcount = 0; |
cd6ce4a9 | 896 | char buf[BUF_TEMP_SIZE]; |
3d4c6a21 | 897 | |
2b5f62a0 | 898 | for ( ;; ) |
c7a9fa36 | 899 | { |
2b5f62a0 VZ |
900 | size_t bytes_read = Read(buf, WXSIZEOF(buf)).LastRead(); |
901 | if ( !bytes_read ) | |
902 | break; | |
903 | ||
904 | if ( stream_out.Write(buf, bytes_read).LastWrite() != bytes_read ) | |
905 | break; | |
68f14620 VZ |
906 | |
907 | lastcount += bytes_read; | |
c7a9fa36 | 908 | } |
2b5f62a0 | 909 | |
68f14620 VZ |
910 | m_lastcount = lastcount; |
911 | ||
c7a9fa36 | 912 | return *this; |
3d4c6a21 GL |
913 | } |
914 | ||
4004775e | 915 | wxFileOffset wxInputStream::SeekI(wxFileOffset pos, wxSeekMode mode) |
75ed1d15 | 916 | { |
adc35078 RR |
917 | // RR: This code is duplicated in wxBufferedInputStream. This is |
918 | // not really a good design, but buffered stream are different | |
8faef7cc | 919 | // from all others in that they handle two stream-related objects: |
adc35078 RR |
920 | // the stream buffer and parent stream. |
921 | ||
922 | // I don't know whether it should be put as well in wxFileInputStream::OnSysSeek | |
cd6ce4a9 | 923 | if (m_lasterror==wxSTREAM_EOF) |
2b5f62a0 | 924 | m_lasterror=wxSTREAM_NO_ERROR; |
c7a9fa36 | 925 | |
8faef7cc FM |
926 | // avoid unnecessary seek operations (optimization) |
927 | wxFileOffset currentPos = TellI(), size = GetLength(); | |
928 | if ((mode == wxFromStart && currentPos == pos) || | |
929 | (mode == wxFromCurrent && pos == 0) || | |
930 | (mode == wxFromEnd && size != wxInvalidOffset && currentPos == size-pos)) | |
931 | return currentPos; | |
932 | ||
933 | if (!IsSeekable() && mode == wxFromCurrent && pos > 0) | |
934 | { | |
935 | // rather than seeking, we can just read data and discard it; | |
936 | // this allows to forward-seek also non-seekable streams! | |
937 | char buf[BUF_TEMP_SIZE]; | |
938 | size_t bytes_read; | |
939 | ||
940 | // read chunks of BUF_TEMP_SIZE bytes until we reach the new position | |
941 | for ( ; pos >= BUF_TEMP_SIZE; pos -= bytes_read) | |
942 | { | |
943 | bytes_read = Read(buf, WXSIZEOF(buf)).LastRead(); | |
944 | if ( m_lasterror != wxSTREAM_NO_ERROR ) | |
945 | return wxInvalidOffset; | |
03647350 | 946 | |
8faef7cc FM |
947 | wxASSERT(bytes_read == WXSIZEOF(buf)); |
948 | } | |
03647350 | 949 | |
8faef7cc FM |
950 | // read the last 'pos' bytes |
951 | bytes_read = Read(buf, (size_t)pos).LastRead(); | |
952 | if ( m_lasterror != wxSTREAM_NO_ERROR ) | |
953 | return wxInvalidOffset; | |
03647350 | 954 | |
8faef7cc | 955 | wxASSERT(bytes_read == (size_t)pos); |
03647350 | 956 | |
8faef7cc FM |
957 | // we should now have seeked to the right position... |
958 | return TellI(); | |
959 | } | |
960 | ||
adc35078 RR |
961 | /* RR: A call to SeekI() will automatically invalidate any previous |
962 | call to Ungetch(), otherwise it would be possible to SeekI() to | |
c7a9fa36 | 963 | one position, unread some bytes there, SeekI() to another position |
19da7237 GRG |
964 | and the data would be corrupted. |
965 | ||
966 | GRG: Could add code here to try to navigate within the wback | |
967 | buffer if possible, but is it really needed? It would only work | |
968 | when seeking in wxFromCurrent mode, else it would invalidate | |
adc35078 | 969 | anyway... */ |
2b5f62a0 | 970 | |
cd6ce4a9 | 971 | if (m_wback) |
c7a9fa36 | 972 | { |
adc35078 | 973 | wxLogDebug( wxT("Seeking in stream which has data written back to it.") ); |
2b5f62a0 | 974 | |
c7a9fa36 | 975 | free(m_wback); |
49e399d8 | 976 | m_wback = NULL; |
c7a9fa36 RR |
977 | m_wbacksize = 0; |
978 | m_wbackcur = 0; | |
979 | } | |
fe8aa971 | 980 | |
c7a9fa36 | 981 | return OnSysSeek(pos, mode); |
75ed1d15 GL |
982 | } |
983 | ||
4004775e | 984 | wxFileOffset wxInputStream::TellI() const |
75ed1d15 | 985 | { |
30984dea | 986 | wxFileOffset pos = OnSysTell(); |
19da7237 GRG |
987 | |
988 | if (pos != wxInvalidOffset) | |
989 | pos -= (m_wbacksize - m_wbackcur); | |
990 | ||
991 | return pos; | |
75ed1d15 GL |
992 | } |
993 | ||
1678ad78 | 994 | |
fae05df5 GL |
995 | // ---------------------------------------------------------------------------- |
996 | // wxOutputStream | |
997 | // ---------------------------------------------------------------------------- | |
49e399d8 | 998 | |
6285e36b VZ |
999 | IMPLEMENT_ABSTRACT_CLASS(wxOutputStream, wxStreamBase) |
1000 | ||
fae05df5 | 1001 | wxOutputStream::wxOutputStream() |
1678ad78 | 1002 | { |
1678ad78 GL |
1003 | } |
1004 | ||
fae05df5 | 1005 | wxOutputStream::~wxOutputStream() |
123a7fdd | 1006 | { |
123a7fdd GL |
1007 | } |
1008 | ||
47fc03d2 VZ |
1009 | size_t wxOutputStream::OnSysWrite(const void * WXUNUSED(buffer), |
1010 | size_t WXUNUSED(bufsize)) | |
1011 | { | |
1012 | return 0; | |
1013 | } | |
1014 | ||
7513f9ff GRG |
1015 | void wxOutputStream::PutC(char c) |
1016 | { | |
2b5f62a0 | 1017 | Write(&c, sizeof(c)); |
7513f9ff GRG |
1018 | } |
1019 | ||
fae05df5 | 1020 | wxOutputStream& wxOutputStream::Write(const void *buffer, size_t size) |
1678ad78 | 1021 | { |
c7a9fa36 RR |
1022 | m_lastcount = OnSysWrite(buffer, size); |
1023 | return *this; | |
1678ad78 GL |
1024 | } |
1025 | ||
fae05df5 | 1026 | wxOutputStream& wxOutputStream::Write(wxInputStream& stream_in) |
38830220 | 1027 | { |
c7a9fa36 RR |
1028 | stream_in.Read(*this); |
1029 | return *this; | |
38830220 RR |
1030 | } |
1031 | ||
4004775e | 1032 | wxFileOffset wxOutputStream::TellO() const |
38830220 | 1033 | { |
c7a9fa36 | 1034 | return OnSysTell(); |
38830220 RR |
1035 | } |
1036 | ||
4004775e | 1037 | wxFileOffset wxOutputStream::SeekO(wxFileOffset pos, wxSeekMode mode) |
38830220 | 1038 | { |
c7a9fa36 | 1039 | return OnSysSeek(pos, mode); |
38830220 RR |
1040 | } |
1041 | ||
fae05df5 | 1042 | void wxOutputStream::Sync() |
1678ad78 | 1043 | { |
1678ad78 GL |
1044 | } |
1045 | ||
123a7fdd | 1046 | |
e2acb9ae RR |
1047 | // ---------------------------------------------------------------------------- |
1048 | // wxCountingOutputStream | |
1049 | // ---------------------------------------------------------------------------- | |
1050 | ||
6285e36b VZ |
1051 | IMPLEMENT_DYNAMIC_CLASS(wxCountingOutputStream, wxOutputStream) |
1052 | ||
e2acb9ae | 1053 | wxCountingOutputStream::wxCountingOutputStream () |
e2acb9ae | 1054 | { |
c7a9fa36 | 1055 | m_currentPos = 0; |
e2acb9ae RR |
1056 | } |
1057 | ||
588066b7 | 1058 | wxFileOffset wxCountingOutputStream::GetLength() const |
e2acb9ae | 1059 | { |
c7a9fa36 | 1060 | return m_lastcount; |
e2acb9ae RR |
1061 | } |
1062 | ||
49e399d8 VZ |
1063 | size_t wxCountingOutputStream::OnSysWrite(const void *WXUNUSED(buffer), |
1064 | size_t size) | |
e2acb9ae | 1065 | { |
c7a9fa36 | 1066 | m_currentPos += size; |
49e399d8 VZ |
1067 | if (m_currentPos > m_lastcount) |
1068 | m_lastcount = m_currentPos; | |
1069 | ||
c7a9fa36 | 1070 | return m_currentPos; |
e2acb9ae RR |
1071 | } |
1072 | ||
4004775e | 1073 | wxFileOffset wxCountingOutputStream::OnSysSeek(wxFileOffset pos, wxSeekMode mode) |
e2acb9ae | 1074 | { |
17a1ebd1 | 1075 | ssize_t new_pos = wx_truncate_cast(ssize_t, pos); |
287d71d9 | 1076 | |
49e399d8 VZ |
1077 | switch ( mode ) |
1078 | { | |
1079 | case wxFromStart: | |
287d71d9 | 1080 | wxCHECK_MSG( (wxFileOffset)new_pos == pos, wxInvalidOffset, wxT("huge position not supported") ); |
49e399d8 VZ |
1081 | break; |
1082 | ||
1083 | case wxFromEnd: | |
287d71d9 WS |
1084 | new_pos = m_lastcount + new_pos; |
1085 | wxCHECK_MSG( (wxFileOffset)new_pos == (wxFileOffset)(m_lastcount + pos), wxInvalidOffset, wxT("huge position not supported") ); | |
49e399d8 VZ |
1086 | break; |
1087 | ||
1088 | case wxFromCurrent: | |
287d71d9 WS |
1089 | new_pos = m_currentPos + new_pos; |
1090 | wxCHECK_MSG( (wxFileOffset)new_pos == (wxFileOffset)(m_currentPos + pos), wxInvalidOffset, wxT("huge position not supported") ); | |
49e399d8 VZ |
1091 | break; |
1092 | ||
1093 | default: | |
9a83f860 | 1094 | wxFAIL_MSG( wxT("invalid seek mode") ); |
30984dea | 1095 | return wxInvalidOffset; |
49e399d8 | 1096 | } |
cd6ce4a9 | 1097 | |
287d71d9 WS |
1098 | m_currentPos = new_pos; |
1099 | ||
49e399d8 VZ |
1100 | if (m_currentPos > m_lastcount) |
1101 | m_lastcount = m_currentPos; | |
cd6ce4a9 | 1102 | |
c7a9fa36 | 1103 | return m_currentPos; |
e2acb9ae RR |
1104 | } |
1105 | ||
4004775e | 1106 | wxFileOffset wxCountingOutputStream::OnSysTell() const |
e2acb9ae | 1107 | { |
c7a9fa36 | 1108 | return m_currentPos; |
e2acb9ae | 1109 | } |
cd6ce4a9 | 1110 | |
1678ad78 | 1111 | // ---------------------------------------------------------------------------- |
fae05df5 | 1112 | // wxFilterInputStream |
1678ad78 | 1113 | // ---------------------------------------------------------------------------- |
e2acb9ae | 1114 | |
6285e36b VZ |
1115 | IMPLEMENT_ABSTRACT_CLASS(wxFilterInputStream, wxInputStream) |
1116 | ||
fae05df5 | 1117 | wxFilterInputStream::wxFilterInputStream() |
166c3ef0 MW |
1118 | : m_parent_i_stream(NULL), |
1119 | m_owns(false) | |
3d4c6a21 | 1120 | { |
6d44bf31 GL |
1121 | } |
1122 | ||
fae05df5 | 1123 | wxFilterInputStream::wxFilterInputStream(wxInputStream& stream) |
166c3ef0 MW |
1124 | : m_parent_i_stream(&stream), |
1125 | m_owns(false) | |
1126 | { | |
1127 | } | |
1128 | ||
1129 | wxFilterInputStream::wxFilterInputStream(wxInputStream *stream) | |
1130 | : m_parent_i_stream(stream), | |
1131 | m_owns(true) | |
6d44bf31 | 1132 | { |
3d4c6a21 GL |
1133 | } |
1134 | ||
fae05df5 | 1135 | wxFilterInputStream::~wxFilterInputStream() |
3d4c6a21 | 1136 | { |
166c3ef0 MW |
1137 | if (m_owns) |
1138 | delete m_parent_i_stream; | |
6d44bf31 GL |
1139 | } |
1140 | ||
fae05df5 GL |
1141 | // ---------------------------------------------------------------------------- |
1142 | // wxFilterOutputStream | |
1143 | // ---------------------------------------------------------------------------- | |
49e399d8 | 1144 | |
6285e36b VZ |
1145 | IMPLEMENT_ABSTRACT_CLASS(wxFilterOutputStream, wxOutputStream) |
1146 | ||
fae05df5 | 1147 | wxFilterOutputStream::wxFilterOutputStream() |
166c3ef0 MW |
1148 | : m_parent_o_stream(NULL), |
1149 | m_owns(false) | |
6d44bf31 | 1150 | { |
3d4c6a21 GL |
1151 | } |
1152 | ||
fae05df5 | 1153 | wxFilterOutputStream::wxFilterOutputStream(wxOutputStream& stream) |
166c3ef0 MW |
1154 | : m_parent_o_stream(&stream), |
1155 | m_owns(false) | |
1156 | { | |
1157 | } | |
1158 | ||
1159 | wxFilterOutputStream::wxFilterOutputStream(wxOutputStream *stream) | |
1160 | : m_parent_o_stream(stream), | |
1161 | m_owns(true) | |
1162 | { | |
1163 | } | |
1164 | ||
1165 | bool wxFilterOutputStream::Close() | |
3d4c6a21 | 1166 | { |
166c3ef0 MW |
1167 | if (m_parent_o_stream && m_owns) |
1168 | return m_parent_o_stream->Close(); | |
1169 | else | |
1170 | return true; | |
6d44bf31 GL |
1171 | } |
1172 | ||
fae05df5 | 1173 | wxFilterOutputStream::~wxFilterOutputStream() |
6d44bf31 | 1174 | { |
166c3ef0 MW |
1175 | if (m_owns) |
1176 | delete m_parent_o_stream; | |
1177 | } | |
1178 | ||
1179 | // ---------------------------------------------------------------------------- | |
58211774 | 1180 | // wxFilterClassFactoryBase |
166c3ef0 MW |
1181 | // ---------------------------------------------------------------------------- |
1182 | ||
58211774 | 1183 | IMPLEMENT_ABSTRACT_CLASS(wxFilterClassFactoryBase, wxObject) |
166c3ef0 | 1184 | |
58211774 | 1185 | wxString wxFilterClassFactoryBase::PopExtension(const wxString& location) const |
166c3ef0 | 1186 | { |
a8d2cf4e MW |
1187 | return location.substr(0, FindExtension(location)); |
1188 | } | |
166c3ef0 | 1189 | |
58211774 | 1190 | wxString::size_type wxFilterClassFactoryBase::FindExtension( |
86501081 | 1191 | const wxString& location) const |
a8d2cf4e | 1192 | { |
489a164c | 1193 | for (const wxChar *const *p = GetProtocols(wxSTREAM_FILEEXT); *p; p++) |
a8d2cf4e | 1194 | { |
86501081 VS |
1195 | if ( location.EndsWith(*p) ) |
1196 | return location.length() - wxStrlen(*p); | |
166c3ef0 | 1197 | } |
a8d2cf4e MW |
1198 | |
1199 | return wxString::npos; | |
1200 | } | |
1201 | ||
86501081 | 1202 | bool wxFilterClassFactoryBase::CanHandle(const wxString& protocol, |
58211774 | 1203 | wxStreamProtocolType type) const |
a8d2cf4e | 1204 | { |
489a164c | 1205 | if (type == wxSTREAM_FILEEXT) |
a8d2cf4e | 1206 | return FindExtension(protocol) != wxString::npos; |
166c3ef0 | 1207 | else |
489a164c | 1208 | for (const wxChar *const *p = GetProtocols(type); *p; p++) |
86501081 | 1209 | if (protocol == *p) |
166c3ef0 | 1210 | return true; |
166c3ef0 MW |
1211 | |
1212 | return false; | |
1213 | } | |
1214 | ||
58211774 MW |
1215 | // ---------------------------------------------------------------------------- |
1216 | // wxFilterClassFactory | |
1217 | // ---------------------------------------------------------------------------- | |
1218 | ||
1219 | IMPLEMENT_ABSTRACT_CLASS(wxFilterClassFactory, wxFilterClassFactoryBase) | |
1220 | ||
1221 | wxFilterClassFactory *wxFilterClassFactory::sm_first = NULL; | |
1222 | ||
166c3ef0 MW |
1223 | void wxFilterClassFactory::Remove() |
1224 | { | |
1225 | if (m_next != this) | |
1226 | { | |
1227 | wxFilterClassFactory **pp = &sm_first; | |
1228 | ||
1229 | while (*pp != this) | |
1230 | pp = &(*pp)->m_next; | |
1231 | ||
1232 | *pp = m_next; | |
1233 | ||
1234 | m_next = this; | |
1235 | } | |
6d44bf31 GL |
1236 | } |
1237 | ||
fae05df5 GL |
1238 | // ---------------------------------------------------------------------------- |
1239 | // wxBufferedInputStream | |
1240 | // ---------------------------------------------------------------------------- | |
49e399d8 | 1241 | |
f42c1512 VZ |
1242 | namespace |
1243 | { | |
1244 | ||
1245 | // helper function used for initializing the buffer used by | |
1246 | // wxBufferedInput/OutputStream: it simply returns the provided buffer if it's | |
1247 | // not NULL or creates a buffer of the given size otherwise | |
1248 | template <typename T> | |
1249 | wxStreamBuffer * | |
1250 | CreateBufferIfNeeded(T& stream, wxStreamBuffer *buffer, size_t bufsize = 1024) | |
1251 | { | |
36f062d3 | 1252 | return buffer ? buffer : new wxStreamBuffer(bufsize, stream); |
f42c1512 VZ |
1253 | } |
1254 | ||
1255 | } // anonymous namespace | |
1256 | ||
1257 | wxBufferedInputStream::wxBufferedInputStream(wxInputStream& stream, | |
47fc03d2 | 1258 | wxStreamBuffer *buffer) |
f42c1512 | 1259 | : wxFilterInputStream(stream) |
6d44bf31 | 1260 | { |
f42c1512 VZ |
1261 | m_i_streambuf = CreateBufferIfNeeded(*this, buffer); |
1262 | } | |
49e399d8 | 1263 | |
f42c1512 VZ |
1264 | wxBufferedInputStream::wxBufferedInputStream(wxInputStream& stream, |
1265 | size_t bufsize) | |
1266 | : wxFilterInputStream(stream) | |
1267 | { | |
1268 | m_i_streambuf = CreateBufferIfNeeded(*this, NULL, bufsize); | |
6d44bf31 GL |
1269 | } |
1270 | ||
fae05df5 | 1271 | wxBufferedInputStream::~wxBufferedInputStream() |
6d44bf31 | 1272 | { |
4004775e | 1273 | m_parent_i_stream->SeekI(-(wxFileOffset)m_i_streambuf->GetBytesLeft(), |
1fb45475 | 1274 | wxFromCurrent); |
672cedf8 | 1275 | |
c7a9fa36 | 1276 | delete m_i_streambuf; |
6d44bf31 GL |
1277 | } |
1278 | ||
6319afe3 GL |
1279 | char wxBufferedInputStream::Peek() |
1280 | { | |
c7a9fa36 | 1281 | return m_i_streambuf->Peek(); |
6319afe3 GL |
1282 | } |
1283 | ||
49e399d8 | 1284 | wxInputStream& wxBufferedInputStream::Read(void *buf, size_t size) |
1e3eca9d | 1285 | { |
e9f69291 | 1286 | // reset the error flag |
2b5f62a0 | 1287 | Reset(); |
1e3eca9d | 1288 | |
e9f69291 VZ |
1289 | // first read from the already cached data |
1290 | m_lastcount = GetWBack(buf, size); | |
1291 | ||
1292 | // do we have to read anything more? | |
1293 | if ( m_lastcount < size ) | |
c7a9fa36 | 1294 | { |
e9f69291 VZ |
1295 | size -= m_lastcount; |
1296 | buf = (char *)buf + m_lastcount; | |
1e3eca9d | 1297 | |
6c91ea6f VZ |
1298 | // the call to wxStreamBuffer::Read() below may reset our m_lastcount |
1299 | // (but it also may not do it if the buffer is associated to another | |
1300 | // existing stream and wasn't created by us), so save it | |
e9f69291 VZ |
1301 | size_t countOld = m_lastcount; |
1302 | ||
6c91ea6f VZ |
1303 | // the new count of the bytes read is the count of bytes read this time |
1304 | m_lastcount = m_i_streambuf->Read(buf, size); | |
e9f69291 | 1305 | |
6c91ea6f | 1306 | // plus those we had read before |
e9f69291 VZ |
1307 | m_lastcount += countOld; |
1308 | } | |
6d44bf31 | 1309 | |
c7a9fa36 | 1310 | return *this; |
6d44bf31 GL |
1311 | } |
1312 | ||
4004775e | 1313 | wxFileOffset wxBufferedInputStream::SeekI(wxFileOffset pos, wxSeekMode mode) |
6d44bf31 | 1314 | { |
adc35078 RR |
1315 | // RR: Look at wxInputStream for comments. |
1316 | ||
1317 | if (m_lasterror==wxSTREAM_EOF) | |
2b5f62a0 | 1318 | Reset(); |
adc35078 RR |
1319 | |
1320 | if (m_wback) | |
1321 | { | |
1322 | wxLogDebug( wxT("Seeking in stream which has data written back to it.") ); | |
2b5f62a0 | 1323 | |
adc35078 RR |
1324 | free(m_wback); |
1325 | m_wback = NULL; | |
1326 | m_wbacksize = 0; | |
1327 | m_wbackcur = 0; | |
1328 | } | |
2b5f62a0 | 1329 | |
c7a9fa36 | 1330 | return m_i_streambuf->Seek(pos, mode); |
6d44bf31 GL |
1331 | } |
1332 | ||
4004775e | 1333 | wxFileOffset wxBufferedInputStream::TellI() const |
6d44bf31 | 1334 | { |
30984dea | 1335 | wxFileOffset pos = m_i_streambuf->Tell(); |
adc35078 RR |
1336 | |
1337 | if (pos != wxInvalidOffset) | |
1338 | pos -= (m_wbacksize - m_wbackcur); | |
2b5f62a0 | 1339 | |
adc35078 | 1340 | return pos; |
38830220 | 1341 | } |
6d44bf31 | 1342 | |
fae05df5 | 1343 | size_t wxBufferedInputStream::OnSysRead(void *buffer, size_t bufsize) |
38830220 | 1344 | { |
c7a9fa36 | 1345 | return m_parent_i_stream->Read(buffer, bufsize).LastRead(); |
38830220 RR |
1346 | } |
1347 | ||
4004775e | 1348 | wxFileOffset wxBufferedInputStream::OnSysSeek(wxFileOffset seek, wxSeekMode mode) |
38830220 | 1349 | { |
c7a9fa36 | 1350 | return m_parent_i_stream->SeekI(seek, mode); |
6d44bf31 GL |
1351 | } |
1352 | ||
4004775e | 1353 | wxFileOffset wxBufferedInputStream::OnSysTell() const |
6d44bf31 | 1354 | { |
c7a9fa36 | 1355 | return m_parent_i_stream->TellI(); |
38830220 | 1356 | } |
6d44bf31 | 1357 | |
47fc03d2 VZ |
1358 | void wxBufferedInputStream::SetInputStreamBuffer(wxStreamBuffer *buffer) |
1359 | { | |
9a83f860 | 1360 | wxCHECK_RET( buffer, wxT("wxBufferedInputStream needs buffer") ); |
47fc03d2 VZ |
1361 | |
1362 | delete m_i_streambuf; | |
1363 | m_i_streambuf = buffer; | |
1364 | } | |
1365 | ||
fae05df5 GL |
1366 | // ---------------------------------------------------------------------------- |
1367 | // wxBufferedOutputStream | |
1368 | // ---------------------------------------------------------------------------- | |
6d44bf31 | 1369 | |
f42c1512 | 1370 | wxBufferedOutputStream::wxBufferedOutputStream(wxOutputStream& stream, |
47fc03d2 | 1371 | wxStreamBuffer *buffer) |
f42c1512 | 1372 | : wxFilterOutputStream(stream) |
6d44bf31 | 1373 | { |
f42c1512 VZ |
1374 | m_o_streambuf = CreateBufferIfNeeded(*this, buffer); |
1375 | } | |
47fc03d2 | 1376 | |
f42c1512 VZ |
1377 | wxBufferedOutputStream::wxBufferedOutputStream(wxOutputStream& stream, |
1378 | size_t bufsize) | |
1379 | : wxFilterOutputStream(stream) | |
1380 | { | |
1381 | m_o_streambuf = CreateBufferIfNeeded(*this, NULL, bufsize); | |
6d44bf31 GL |
1382 | } |
1383 | ||
fae05df5 | 1384 | wxBufferedOutputStream::~wxBufferedOutputStream() |
6d44bf31 | 1385 | { |
c7a9fa36 RR |
1386 | Sync(); |
1387 | delete m_o_streambuf; | |
3d4c6a21 GL |
1388 | } |
1389 | ||
8f0ff178 RN |
1390 | bool wxBufferedOutputStream::Close() |
1391 | { | |
1392 | Sync(); | |
1393 | return IsOk(); | |
1394 | } | |
1395 | ||
1396 | ||
fae05df5 | 1397 | wxOutputStream& wxBufferedOutputStream::Write(const void *buffer, size_t size) |
123a7fdd | 1398 | { |
c7a9fa36 RR |
1399 | m_lastcount = 0; |
1400 | m_o_streambuf->Write(buffer, size); | |
1401 | return *this; | |
123a7fdd GL |
1402 | } |
1403 | ||
4004775e | 1404 | wxFileOffset wxBufferedOutputStream::SeekO(wxFileOffset pos, wxSeekMode mode) |
f4ada568 | 1405 | { |
c7a9fa36 RR |
1406 | Sync(); |
1407 | return m_o_streambuf->Seek(pos, mode); | |
f4ada568 GL |
1408 | } |
1409 | ||
4004775e | 1410 | wxFileOffset wxBufferedOutputStream::TellO() const |
3d4c6a21 | 1411 | { |
c7a9fa36 | 1412 | return m_o_streambuf->Tell(); |
3d4c6a21 GL |
1413 | } |
1414 | ||
fae05df5 | 1415 | void wxBufferedOutputStream::Sync() |
3d4c6a21 | 1416 | { |
c7a9fa36 RR |
1417 | m_o_streambuf->FlushBuffer(); |
1418 | m_parent_o_stream->Sync(); | |
3d4c6a21 | 1419 | } |
219f895a | 1420 | |
fae05df5 | 1421 | size_t wxBufferedOutputStream::OnSysWrite(const void *buffer, size_t bufsize) |
f4ada568 | 1422 | { |
c7a9fa36 | 1423 | return m_parent_o_stream->Write(buffer, bufsize).LastWrite(); |
f4ada568 GL |
1424 | } |
1425 | ||
4004775e | 1426 | wxFileOffset wxBufferedOutputStream::OnSysSeek(wxFileOffset seek, wxSeekMode mode) |
219f895a | 1427 | { |
c7a9fa36 | 1428 | return m_parent_o_stream->SeekO(seek, mode); |
219f895a RR |
1429 | } |
1430 | ||
4004775e | 1431 | wxFileOffset wxBufferedOutputStream::OnSysTell() const |
219f895a | 1432 | { |
c7a9fa36 RR |
1433 | return m_parent_o_stream->TellO(); |
1434 | } | |
1435 | ||
588066b7 | 1436 | wxFileOffset wxBufferedOutputStream::GetLength() const |
c7a9fa36 | 1437 | { |
588066b7 | 1438 | return m_parent_o_stream->GetLength() + m_o_streambuf->GetIntPosition(); |
219f895a | 1439 | } |
6d44bf31 | 1440 | |
47fc03d2 VZ |
1441 | void wxBufferedOutputStream::SetOutputStreamBuffer(wxStreamBuffer *buffer) |
1442 | { | |
9a83f860 | 1443 | wxCHECK_RET( buffer, wxT("wxBufferedOutputStream needs buffer") ); |
47fc03d2 VZ |
1444 | |
1445 | delete m_o_streambuf; | |
1446 | m_o_streambuf = buffer; | |
1447 | } | |
1448 | ||
6d44bf31 GL |
1449 | // ---------------------------------------------------------------------------- |
1450 | // Some IOManip function | |
1451 | // ---------------------------------------------------------------------------- | |
1452 | ||
1453 | wxOutputStream& wxEndL(wxOutputStream& stream) | |
1454 | { | |
733b8ed3 VZ |
1455 | static const wxChar *eol = wxTextFile::GetEOL(); |
1456 | ||
1457 | return stream.Write(eol, wxStrlen(eol)); | |
6d44bf31 | 1458 | } |
ce4169a4 | 1459 | |
15dc68b6 | 1460 | #endif // wxUSE_STREAMS |