]>
Commit | Line | Data |
---|---|---|
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$ | |
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 && wxUSE_FILE | |
24 | ||
25 | #include <stdio.h> | |
26 | #include "wx/stream.h" | |
27 | #include "wx/wfstream.h" | |
28 | ||
29 | // ---------------------------------------------------------------------------- | |
30 | // wxFileInputStream | |
31 | // ---------------------------------------------------------------------------- | |
32 | ||
33 | wxFileInputStream::wxFileInputStream(const wxString& fileName) | |
34 | : wxInputStream() | |
35 | { | |
36 | m_file = new wxFile(fileName, wxFile::read); | |
37 | m_file_destroy = true; | |
38 | } | |
39 | ||
40 | wxFileInputStream::wxFileInputStream() | |
41 | : wxInputStream() | |
42 | { | |
43 | m_file_destroy = false; | |
44 | m_file = NULL; | |
45 | } | |
46 | ||
47 | wxFileInputStream::wxFileInputStream(wxFile& file) | |
48 | { | |
49 | m_file = &file; | |
50 | m_file_destroy = false; | |
51 | } | |
52 | ||
53 | wxFileInputStream::wxFileInputStream(int fd) | |
54 | { | |
55 | m_file = new wxFile(fd); | |
56 | m_file_destroy = true; | |
57 | } | |
58 | ||
59 | wxFileInputStream::~wxFileInputStream() | |
60 | { | |
61 | if (m_file_destroy) | |
62 | delete m_file; | |
63 | } | |
64 | ||
65 | size_t wxFileInputStream::GetSize() const | |
66 | { | |
67 | return m_file->Length(); | |
68 | } | |
69 | ||
70 | size_t wxFileInputStream::OnSysRead(void *buffer, size_t size) | |
71 | { | |
72 | off_t ret = m_file->Read(buffer, size); | |
73 | ||
74 | // NB: we can't use a switch here because HP-UX CC doesn't allow | |
75 | // switching over long long (which off_t is in 64bit mode) | |
76 | ||
77 | if ( !ret ) | |
78 | { | |
79 | // nothing read, so nothing more to read | |
80 | m_lasterror = wxSTREAM_EOF; | |
81 | } | |
82 | else if ( ret == wxInvalidOffset ) | |
83 | { | |
84 | m_lasterror = wxSTREAM_READ_ERROR; | |
85 | ret = 0; | |
86 | } | |
87 | else | |
88 | { | |
89 | // normal case | |
90 | m_lasterror = wxSTREAM_NO_ERROR; | |
91 | } | |
92 | ||
93 | return ret; | |
94 | } | |
95 | ||
96 | off_t wxFileInputStream::OnSysSeek(off_t pos, wxSeekMode mode) | |
97 | { | |
98 | return m_file->Seek(pos, mode); | |
99 | } | |
100 | ||
101 | off_t wxFileInputStream::OnSysTell() const | |
102 | { | |
103 | return m_file->Tell(); | |
104 | } | |
105 | ||
106 | // ---------------------------------------------------------------------------- | |
107 | // wxFileOutputStream | |
108 | // ---------------------------------------------------------------------------- | |
109 | ||
110 | wxFileOutputStream::wxFileOutputStream(const wxString& fileName) | |
111 | { | |
112 | m_file = new wxFile(fileName, wxFile::write); | |
113 | m_file_destroy = true; | |
114 | ||
115 | if (!m_file->IsOpened()) | |
116 | { | |
117 | m_lasterror = wxSTREAM_WRITE_ERROR; | |
118 | } | |
119 | else | |
120 | { | |
121 | if (m_file->Error()) | |
122 | m_lasterror = wxSTREAM_WRITE_ERROR; | |
123 | } | |
124 | } | |
125 | ||
126 | wxFileOutputStream::wxFileOutputStream(wxFile& file) | |
127 | { | |
128 | m_file = &file; | |
129 | m_file_destroy = false; | |
130 | } | |
131 | ||
132 | wxFileOutputStream::wxFileOutputStream() | |
133 | : wxOutputStream() | |
134 | { | |
135 | m_file_destroy = false; | |
136 | m_file = NULL; | |
137 | } | |
138 | ||
139 | wxFileOutputStream::wxFileOutputStream(int fd) | |
140 | { | |
141 | m_file = new wxFile(fd); | |
142 | m_file_destroy = true; | |
143 | } | |
144 | ||
145 | wxFileOutputStream::~wxFileOutputStream() | |
146 | { | |
147 | if (m_file_destroy) | |
148 | { | |
149 | Sync(); | |
150 | delete m_file; | |
151 | } | |
152 | } | |
153 | ||
154 | size_t wxFileOutputStream::OnSysWrite(const void *buffer, size_t size) | |
155 | { | |
156 | size_t ret = m_file->Write(buffer, size); | |
157 | ||
158 | m_lasterror = m_file->Error() ? wxSTREAM_WRITE_ERROR : wxSTREAM_NO_ERROR; | |
159 | ||
160 | return ret; | |
161 | } | |
162 | ||
163 | off_t wxFileOutputStream::OnSysTell() const | |
164 | { | |
165 | return m_file->Tell(); | |
166 | } | |
167 | ||
168 | off_t wxFileOutputStream::OnSysSeek(off_t pos, wxSeekMode mode) | |
169 | { | |
170 | return m_file->Seek(pos, mode); | |
171 | } | |
172 | ||
173 | void wxFileOutputStream::Sync() | |
174 | { | |
175 | wxOutputStream::Sync(); | |
176 | m_file->Flush(); | |
177 | } | |
178 | ||
179 | size_t wxFileOutputStream::GetSize() const | |
180 | { | |
181 | return m_file->Length(); | |
182 | } | |
183 | ||
184 | // ---------------------------------------------------------------------------- | |
185 | // wxFileStream | |
186 | // ---------------------------------------------------------------------------- | |
187 | ||
188 | wxFileStream::wxFileStream(const wxString& fileName) | |
189 | : wxFileInputStream(fileName) | |
190 | { | |
191 | wxFileOutputStream::m_file = wxFileInputStream::m_file; | |
192 | } | |
193 | ||
194 | // ---------------------------------------------------------------------------- | |
195 | // wxFFileInputStream | |
196 | // ---------------------------------------------------------------------------- | |
197 | ||
198 | wxFFileInputStream::wxFFileInputStream(const wxString& fileName) | |
199 | : wxInputStream() | |
200 | { | |
201 | m_file = new wxFFile(fileName, _T("rb")); | |
202 | m_file_destroy = true; | |
203 | } | |
204 | ||
205 | wxFFileInputStream::wxFFileInputStream() | |
206 | : wxInputStream() | |
207 | { | |
208 | m_file_destroy = false; | |
209 | m_file = NULL; | |
210 | } | |
211 | ||
212 | wxFFileInputStream::wxFFileInputStream(wxFFile& file) | |
213 | { | |
214 | m_file = &file; | |
215 | m_file_destroy = false; | |
216 | } | |
217 | ||
218 | wxFFileInputStream::wxFFileInputStream(FILE *file) | |
219 | { | |
220 | m_file = new wxFFile(file); | |
221 | m_file_destroy = true; | |
222 | } | |
223 | ||
224 | wxFFileInputStream::~wxFFileInputStream() | |
225 | { | |
226 | if (m_file_destroy) | |
227 | delete m_file; | |
228 | } | |
229 | ||
230 | size_t wxFFileInputStream::GetSize() const | |
231 | { | |
232 | return m_file->Length(); | |
233 | } | |
234 | ||
235 | size_t wxFFileInputStream::OnSysRead(void *buffer, size_t size) | |
236 | { | |
237 | off_t ret; | |
238 | ||
239 | ret = m_file->Read(buffer, size); | |
240 | ||
241 | if (m_file->Eof()) | |
242 | m_lasterror = wxSTREAM_EOF; | |
243 | if (ret == wxInvalidOffset) | |
244 | { | |
245 | m_lasterror = wxSTREAM_READ_ERROR; | |
246 | ret = 0; | |
247 | } | |
248 | ||
249 | return ret; | |
250 | } | |
251 | ||
252 | off_t wxFFileInputStream::OnSysSeek(off_t pos, wxSeekMode mode) | |
253 | { | |
254 | #ifdef __VMS | |
255 | #pragma message disable intsignchange | |
256 | #endif | |
257 | return ( m_file->Seek(pos, mode) ? m_file->Tell() : wxInvalidOffset ); | |
258 | #ifdef __VMS | |
259 | #pragma message enable intsignchange | |
260 | #endif | |
261 | } | |
262 | ||
263 | off_t wxFFileInputStream::OnSysTell() const | |
264 | { | |
265 | return m_file->Tell(); | |
266 | } | |
267 | ||
268 | // ---------------------------------------------------------------------------- | |
269 | // wxFFileOutputStream | |
270 | // ---------------------------------------------------------------------------- | |
271 | ||
272 | wxFFileOutputStream::wxFFileOutputStream(const wxString& fileName) | |
273 | { | |
274 | m_file = new wxFFile(fileName, _T("w+b")); | |
275 | m_file_destroy = true; | |
276 | ||
277 | if (!m_file->IsOpened()) | |
278 | { | |
279 | m_lasterror = wxSTREAM_WRITE_ERROR; | |
280 | } | |
281 | else | |
282 | { | |
283 | if (m_file->Error()) | |
284 | m_lasterror = wxSTREAM_WRITE_ERROR; | |
285 | } | |
286 | } | |
287 | ||
288 | wxFFileOutputStream::wxFFileOutputStream(wxFFile& file) | |
289 | { | |
290 | m_file = &file; | |
291 | m_file_destroy = false; | |
292 | } | |
293 | ||
294 | wxFFileOutputStream::wxFFileOutputStream() | |
295 | : wxOutputStream() | |
296 | { | |
297 | m_file_destroy = false; | |
298 | m_file = NULL; | |
299 | } | |
300 | ||
301 | wxFFileOutputStream::wxFFileOutputStream(FILE *file) | |
302 | { | |
303 | m_file = new wxFFile(file); | |
304 | m_file_destroy = true; | |
305 | } | |
306 | ||
307 | wxFFileOutputStream::~wxFFileOutputStream() | |
308 | { | |
309 | if (m_file_destroy) | |
310 | { | |
311 | Sync(); | |
312 | delete m_file; | |
313 | } | |
314 | } | |
315 | ||
316 | size_t wxFFileOutputStream::OnSysWrite(const void *buffer, size_t size) | |
317 | { | |
318 | size_t ret = m_file->Write(buffer, size); | |
319 | if (m_file->Error()) | |
320 | m_lasterror = wxSTREAM_WRITE_ERROR; | |
321 | else | |
322 | m_lasterror = wxSTREAM_NO_ERROR; | |
323 | return ret; | |
324 | } | |
325 | ||
326 | off_t wxFFileOutputStream::OnSysTell() const | |
327 | { | |
328 | return m_file->Tell(); | |
329 | } | |
330 | ||
331 | off_t wxFFileOutputStream::OnSysSeek(off_t pos, wxSeekMode mode) | |
332 | { | |
333 | #ifdef __VMS | |
334 | #pragma message disable intsignchange | |
335 | #endif | |
336 | return ( m_file->Seek(pos, mode) ? m_file->Tell() : wxInvalidOffset ); | |
337 | #ifdef __VMS | |
338 | #pragma message enable intsignchange | |
339 | #endif | |
340 | } | |
341 | ||
342 | void wxFFileOutputStream::Sync() | |
343 | { | |
344 | wxOutputStream::Sync(); | |
345 | m_file->Flush(); | |
346 | } | |
347 | ||
348 | size_t wxFFileOutputStream::GetSize() const | |
349 | { | |
350 | return m_file->Length(); | |
351 | } | |
352 | ||
353 | // ---------------------------------------------------------------------------- | |
354 | // wxFFileStream | |
355 | // ---------------------------------------------------------------------------- | |
356 | ||
357 | wxFFileStream::wxFFileStream(const wxString& fileName) | |
358 | : wxFFileInputStream(fileName) | |
359 | { | |
360 | wxFFileOutputStream::m_file = wxFFileInputStream::m_file; | |
361 | } | |
362 | ||
363 | #endif | |
364 | // wxUSE_STREAMS && wxUSE_FILE | |
365 |