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$
   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 wxFileOffset wxFileInputStream::GetLength() const
  66 {
  67     return m_file->Length();
  68 }
  69
  70 size_t wxFileInputStream::OnSysRead(void *buffer, size_t size)
  71 {
  72     ssize_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 size_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 wxFileOffset wxFileInputStream::OnSysSeek(wxFileOffset pos, wxSeekMode mode)
  97 {
  98     return m_file->Seek(pos, mode);
  99 }
 100
 101 wxFileOffset 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 wxFileOffset wxFileOutputStream::OnSysTell() const
 164 {
 165     return m_file->Tell();
 166 }
 167
 168 wxFileOffset wxFileOutputStream::OnSysSeek(wxFileOffset 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 wxFileOffset wxFileOutputStream::GetLength() 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 wxFileOffset wxFFileInputStream::GetLength() const
 231 {
 232     return m_file->Length();
 233 }
 234
 235 size_t wxFFileInputStream::OnSysRead(void *buffer, size_t size)
 236 {
 237     ssize_t ret = m_file->Read(buffer, size);
 238
 239     // It is not safe to call Eof() if the file is not opened.
 240     if (!m_file->IsOpened() || m_file->Eof())
 241         m_lasterror = wxSTREAM_EOF;
 242     if (ret == wxInvalidOffset)
 243     {
 244         m_lasterror = wxSTREAM_READ_ERROR;
 245         ret = 0;
 246     }
 247
 248     return ret;
 249 }
 250
 251 wxFileOffset wxFFileInputStream::OnSysSeek(wxFileOffset pos, wxSeekMode mode)
 252 {
 253 #ifdef __VMS
 254 #pragma message disable intsignchange
 255 #endif
 256    return ( m_file->Seek(pos, mode) ? (wxFileOffset)m_file->Tell() : wxInvalidOffset );
 257 #ifdef __VMS
 258 #pragma message enable intsignchange
 259 #endif
 260 }
 261
 262 wxFileOffset wxFFileInputStream::OnSysTell() const
 263 {
 264     return m_file->Tell();
 265 }
 266
 267 // ----------------------------------------------------------------------------
 268 // wxFFileOutputStream
 269 // ----------------------------------------------------------------------------
 270
 271 wxFFileOutputStream::wxFFileOutputStream(const wxString& fileName)
 272 {
 273     m_file = new wxFFile(fileName, _T("w+b"));
 274     m_file_destroy = true;
 275
 276     if (!m_file->IsOpened())
 277     {
 278         m_lasterror = wxSTREAM_WRITE_ERROR;
 279     }
 280     else
 281     {
 282         if (m_file->Error())
 283             m_lasterror = wxSTREAM_WRITE_ERROR;
 284     }
 285 }
 286
 287 wxFFileOutputStream::wxFFileOutputStream(wxFFile& file)
 288 {
 289     m_file = &file;
 290     m_file_destroy = false;
 291 }
 292
 293 wxFFileOutputStream::wxFFileOutputStream()
 294   : wxOutputStream()
 295 {
 296     m_file_destroy = false;
 297     m_file = NULL;
 298 }
 299
 300 wxFFileOutputStream::wxFFileOutputStream(FILE *file)
 301 {
 302     m_file = new wxFFile(file);
 303     m_file_destroy = true;
 304 }
 305
 306 wxFFileOutputStream::~wxFFileOutputStream()
 307 {
 308     if (m_file_destroy)
 309     {
 310         Sync();
 311         delete m_file;
 312     }
 313 }
 314
 315 size_t wxFFileOutputStream::OnSysWrite(const void *buffer, size_t size)
 316 {
 317     size_t ret = m_file->Write(buffer, size);
 318     // It is not safe to call Error() if the file is not opened.
 319     if (!m_file->IsOpened() || m_file->Error())
 320         m_lasterror = wxSTREAM_WRITE_ERROR;
 321     else
 322         m_lasterror = wxSTREAM_NO_ERROR;
 323     return ret;
 324 }
 325
 326 wxFileOffset wxFFileOutputStream::OnSysTell() const
 327 {
 328     return m_file->Tell();
 329 }
 330
 331 wxFileOffset wxFFileOutputStream::OnSysSeek(wxFileOffset pos, wxSeekMode mode)
 332 {
 333 #ifdef __VMS
 334 #pragma message disable intsignchange
 335 #endif
 336     return ( m_file->Seek(pos, mode) ? (wxFileOffset)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 wxFileOffset wxFFileOutputStream::GetLength() 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