← Back to branch summary

~ubuntu-dev/wxwidgets2.6/upstream-debian

« back to all changes in this revision

Viewing changes to src/common/wfstream.cpp

  • Committer: Daniel T Chen
  • Date: 2006-06-26 10:15:11 UTC
  • Revision ID: crimsun@ubuntu.com-20060626101511-a4436cec4c6d9b35
Import Debian 2.6.3.2.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/common/wfstream.cpp
 
1
/////////////////////////////////////////////////////////////////////////////
 
2
// Name:        fstream.cpp
 
3
// Purpose:     "File stream" classes
 
4
// Author:      Julian Smart
 
5
// Modified by:
 
6
// Created:     11/07/98
 
7
// RCS-ID:      $Id: wfstream.cpp,v 1.41 2005/08/13 20:53:13 MW Exp $
 
8
// Copyright:   (c) Guilhem Lavaux
 
9
// Licence:     wxWindows licence
 
10
/////////////////////////////////////////////////////////////////////////////
 
11
 
 
12
#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
 
13
#pragma implementation "wfstream.h"
 
14
#endif
 
15
 
 
16
// For compilers that support precompilation, includes "wx.h".
 
17
#include "wx/wxprec.h"
 
18
 
 
19
#ifdef __BORLANDC__
 
20
  #pragma hdrstop
 
21
#endif
 
22
 
 
23
#if wxUSE_STREAMS
 
24
 
 
25
#include <stdio.h>
 
26
#include "wx/stream.h"
 
27
#include "wx/wfstream.h"
 
28
 
 
29
#if wxUSE_FILE
 
30
 
 
31
// ----------------------------------------------------------------------------
 
32
// wxFileInputStream
 
33
// ----------------------------------------------------------------------------
 
34
 
 
35
wxFileInputStream::wxFileInputStream(const wxString& fileName)
 
36
  : wxInputStream()
 
37
{
 
38
    m_file = new wxFile(fileName, wxFile::read);
 
39
    m_file_destroy = true;
 
40
    if ( !m_file->IsOpened() )
 
41
        m_lasterror = wxSTREAM_READ_ERROR;
 
42
}
 
43
 
 
44
wxFileInputStream::wxFileInputStream()
 
45
  : wxInputStream()
 
46
{
 
47
    m_file_destroy = false;
 
48
    m_file = NULL;
 
49
}
 
50
 
 
51
wxFileInputStream::wxFileInputStream(wxFile& file)
 
52
{
 
53
    m_file = &file;
 
54
    m_file_destroy = false;
 
55
}
 
56
 
 
57
wxFileInputStream::wxFileInputStream(int fd)
 
58
{
 
59
    m_file = new wxFile(fd);
 
60
    m_file_destroy = true;
 
61
}
 
62
 
 
63
wxFileInputStream::~wxFileInputStream()
 
64
{
 
65
    if (m_file_destroy)
 
66
        delete m_file;
 
67
}
 
68
 
 
69
wxFileOffset wxFileInputStream::GetLength() const
 
70
{
 
71
    return m_file->Length();
 
72
}
 
73
 
 
74
size_t wxFileInputStream::OnSysRead(void *buffer, size_t size)
 
75
{
 
76
    ssize_t ret = m_file->Read(buffer, size);
 
77
 
 
78
    // NB: we can't use a switch here because HP-UX CC doesn't allow
 
79
    //     switching over long long (which size_t is in 64bit mode)
 
80
 
 
81
    if ( !ret )
 
82
    {
 
83
        // nothing read, so nothing more to read
 
84
        m_lasterror = wxSTREAM_EOF;
 
85
    }
 
86
    else if ( ret == wxInvalidOffset )
 
87
    {
 
88
        m_lasterror = wxSTREAM_READ_ERROR;
 
89
        ret = 0;
 
90
    }
 
91
    else
 
92
    {
 
93
        // normal case
 
94
        m_lasterror = wxSTREAM_NO_ERROR;
 
95
    }
 
96
 
 
97
    return ret;
 
98
}
 
99
 
 
100
wxFileOffset wxFileInputStream::OnSysSeek(wxFileOffset pos, wxSeekMode mode)
 
101
{
 
102
    return m_file->Seek(pos, mode);
 
103
}
 
104
 
 
105
wxFileOffset wxFileInputStream::OnSysTell() const
 
106
{
 
107
    return m_file->Tell();
 
108
}
 
109
 
 
110
// ----------------------------------------------------------------------------
 
111
// wxFileOutputStream
 
112
// ----------------------------------------------------------------------------
 
113
 
 
114
wxFileOutputStream::wxFileOutputStream(const wxString& fileName)
 
115
{
 
116
    m_file = new wxFile(fileName, wxFile::write);
 
117
    m_file_destroy = true;
 
118
 
 
119
    if (!m_file->IsOpened())
 
120
        m_lasterror = wxSTREAM_WRITE_ERROR;
 
121
}
 
122
 
 
123
wxFileOutputStream::wxFileOutputStream(wxFile& file)
 
124
{
 
125
    m_file = &file;
 
126
    m_file_destroy = false;
 
127
}
 
128
 
 
129
wxFileOutputStream::wxFileOutputStream()
 
130
                  : wxOutputStream()
 
131
{
 
132
    m_file_destroy = false;
 
133
    m_file = NULL;
 
134
}
 
135
 
 
136
wxFileOutputStream::wxFileOutputStream(int fd)
 
137
{
 
138
    m_file = new wxFile(fd);
 
139
    m_file_destroy = true;
 
140
}
 
141
 
 
142
wxFileOutputStream::~wxFileOutputStream()
 
143
{
 
144
    if (m_file_destroy)
 
145
    {
 
146
        Sync();
 
147
        delete m_file;
 
148
    }
 
149
}
 
150
 
 
151
size_t wxFileOutputStream::OnSysWrite(const void *buffer, size_t size)
 
152
{
 
153
    size_t ret = m_file->Write(buffer, size);
 
154
 
 
155
    m_lasterror = m_file->Error() ? wxSTREAM_WRITE_ERROR : wxSTREAM_NO_ERROR;
 
156
 
 
157
    return ret;
 
158
}
 
159
 
 
160
wxFileOffset wxFileOutputStream::OnSysTell() const
 
161
{
 
162
    return m_file->Tell();
 
163
}
 
164
 
 
165
wxFileOffset wxFileOutputStream::OnSysSeek(wxFileOffset pos, wxSeekMode mode)
 
166
{
 
167
    return m_file->Seek(pos, mode);
 
168
}
 
169
 
 
170
void wxFileOutputStream::Sync()
 
171
{
 
172
    wxOutputStream::Sync();
 
173
    m_file->Flush();
 
174
}
 
175
 
 
176
wxFileOffset wxFileOutputStream::GetLength() const
 
177
{
 
178
    return m_file->Length();
 
179
}
 
180
 
 
181
// ----------------------------------------------------------------------------
 
182
// wxTempFileOutputStream
 
183
// ----------------------------------------------------------------------------
 
184
 
 
185
wxTempFileOutputStream::wxTempFileOutputStream(const wxString& fileName)
 
186
{
 
187
    m_file = new wxTempFile(fileName);
 
188
 
 
189
    if (!m_file->IsOpened())
 
190
        m_lasterror = wxSTREAM_WRITE_ERROR;
 
191
}
 
192
 
 
193
wxTempFileOutputStream::~wxTempFileOutputStream()
 
194
{
 
195
    if (m_file->IsOpened())
 
196
        Discard();
 
197
    delete m_file;
 
198
}
 
199
 
 
200
size_t wxTempFileOutputStream::OnSysWrite(const void *buffer, size_t size)
 
201
{
 
202
    if (IsOk() && m_file->Write(buffer, size))
 
203
        return size;
 
204
    m_lasterror = wxSTREAM_WRITE_ERROR;
 
205
    return 0;
 
206
}
 
207
 
 
208
// ----------------------------------------------------------------------------
 
209
// wxFileStream
 
210
// ----------------------------------------------------------------------------
 
211
 
 
212
wxFileStream::wxFileStream(const wxString& fileName)
 
213
            : wxFileInputStream(fileName)
 
214
{
 
215
    wxFileOutputStream::m_file = wxFileInputStream::m_file;
 
216
}
 
217
 
 
218
#endif //wxUSE_FILE
 
219
 
 
220
#if wxUSE_FFILE
 
221
 
 
222
// ----------------------------------------------------------------------------
 
223
// wxFFileInputStream
 
224
// ----------------------------------------------------------------------------
 
225
 
 
226
wxFFileInputStream::wxFFileInputStream(const wxString& fileName,
 
227
                                       const wxChar *mode)
 
228
                  : wxInputStream()
 
229
{
 
230
    m_file = new wxFFile(fileName, mode);
 
231
    m_file_destroy = true;
 
232
 
 
233
    if (!m_file->IsOpened())
 
234
        m_lasterror = wxSTREAM_WRITE_ERROR;
 
235
}
 
236
 
 
237
wxFFileInputStream::wxFFileInputStream()
 
238
                  : wxInputStream()
 
239
{
 
240
    m_file = NULL;
 
241
    m_file_destroy = false;
 
242
}
 
243
 
 
244
wxFFileInputStream::wxFFileInputStream(wxFFile& file)
 
245
{
 
246
    m_file = &file;
 
247
    m_file_destroy = false;
 
248
}
 
249
 
 
250
wxFFileInputStream::wxFFileInputStream(FILE *file)
 
251
{
 
252
    m_file = new wxFFile(file);
 
253
    m_file_destroy = true;
 
254
}
 
255
 
 
256
wxFFileInputStream::~wxFFileInputStream()
 
257
{
 
258
    if (m_file_destroy)
 
259
        delete m_file;
 
260
}
 
261
 
 
262
wxFileOffset wxFFileInputStream::GetLength() const
 
263
{
 
264
    return m_file->Length();
 
265
}
 
266
 
 
267
size_t wxFFileInputStream::OnSysRead(void *buffer, size_t size)
 
268
{
 
269
    ssize_t ret = m_file->Read(buffer, size);
 
270
 
 
271
    // It is not safe to call Eof() if the file is not opened.
 
272
    if (!m_file->IsOpened() || m_file->Eof())
 
273
        m_lasterror = wxSTREAM_EOF;
 
274
    if (ret == wxInvalidOffset)
 
275
    {
 
276
        m_lasterror = wxSTREAM_READ_ERROR;
 
277
        ret = 0;
 
278
    }
 
279
 
 
280
    return ret;
 
281
}
 
282
 
 
283
wxFileOffset wxFFileInputStream::OnSysSeek(wxFileOffset pos, wxSeekMode mode)
 
284
{
 
285
    return m_file->Seek(pos, mode) ? m_file->Tell() : wxInvalidOffset;
 
286
}
 
287
 
 
288
wxFileOffset wxFFileInputStream::OnSysTell() const
 
289
{
 
290
    return m_file->Tell();
 
291
}
 
292
 
 
293
// ----------------------------------------------------------------------------
 
294
// wxFFileOutputStream
 
295
// ----------------------------------------------------------------------------
 
296
 
 
297
wxFFileOutputStream::wxFFileOutputStream(const wxString& fileName,
 
298
                                         const wxChar *mode)
 
299
{
 
300
    m_file = new wxFFile(fileName, mode);
 
301
    m_file_destroy = true;
 
302
 
 
303
    if (!m_file->IsOpened())
 
304
    {
 
305
        m_lasterror = wxSTREAM_WRITE_ERROR;
 
306
    }
 
307
    else
 
308
    {
 
309
        if (m_file->Error())
 
310
            m_lasterror = wxSTREAM_WRITE_ERROR;
 
311
    }
 
312
}
 
313
 
 
314
wxFFileOutputStream::wxFFileOutputStream(wxFFile& file)
 
315
{
 
316
    m_file = &file;
 
317
    m_file_destroy = false;
 
318
}
 
319
 
 
320
wxFFileOutputStream::wxFFileOutputStream()
 
321
                   : wxOutputStream()
 
322
{
 
323
    m_file = NULL;
 
324
    m_file_destroy = false;
 
325
}
 
326
 
 
327
wxFFileOutputStream::wxFFileOutputStream(FILE *file)
 
328
{
 
329
    m_file = new wxFFile(file);
 
330
    m_file_destroy = true;
 
331
}
 
332
 
 
333
wxFFileOutputStream::~wxFFileOutputStream()
 
334
{
 
335
    if (m_file_destroy)
 
336
    {
 
337
        Sync();
 
338
        delete m_file;
 
339
    }
 
340
}
 
341
 
 
342
size_t wxFFileOutputStream::OnSysWrite(const void *buffer, size_t size)
 
343
{
 
344
    size_t ret = m_file->Write(buffer, size);
 
345
    // It is not safe to call Error() if the file is not opened.
 
346
    if (!m_file->IsOpened() || m_file->Error())
 
347
        m_lasterror = wxSTREAM_WRITE_ERROR;
 
348
    else
 
349
        m_lasterror = wxSTREAM_NO_ERROR;
 
350
    return ret;
 
351
}
 
352
 
 
353
wxFileOffset wxFFileOutputStream::OnSysTell() const
 
354
{
 
355
    return m_file->Tell();
 
356
}
 
357
 
 
358
wxFileOffset wxFFileOutputStream::OnSysSeek(wxFileOffset pos, wxSeekMode mode)
 
359
{
 
360
    return m_file->Seek(pos, mode) ? m_file->Tell() : wxInvalidOffset;
 
361
}
 
362
 
 
363
void wxFFileOutputStream::Sync()
 
364
{
 
365
    wxOutputStream::Sync();
 
366
    m_file->Flush();
 
367
}
 
368
 
 
369
wxFileOffset wxFFileOutputStream::GetLength() const
 
370
{
 
371
    return m_file->Length();
 
372
}
 
373
 
 
374
// ----------------------------------------------------------------------------
 
375
// wxFFileStream
 
376
// ----------------------------------------------------------------------------
 
377
 
 
378
wxFFileStream::wxFFileStream(const wxString& fileName)
 
379
             : wxFFileInputStream(fileName)
 
380
{
 
381
    wxFFileOutputStream::m_file = wxFFileInputStream::m_file;
 
382
}
 
383
 
 
384
#endif //wxUSE_FFILE
 
385
 
 
386
#endif // wxUSE_STREAMS
 
387