src/common/fileback.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/fileback.cpp
   3 // Purpose:     Back an input stream with memory or a file
   4 // Author:      Mike Wetherell
   5 // RCS-ID:      $Id$
   6 // Copyright:   (c) 2006 Mike Wetherell
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 // For compilers that support precompilation, includes "wx.h".
  11 #include "wx/wxprec.h"
  12
  13 #ifdef __BORLANDC__
  14     #pragma hdrstop
  15 #endif
  16
  17 #if wxUSE_BACKINGFILE
  18
  19 #include "wx/fileback.h"
  20
  21 #ifndef WX_PRECOMP
  22     #include "wx/utils.h"
  23     #include "wx/log.h"
  24 #endif
  25
  26 #include "wx/private/filename.h"
  27
  28 // Prefer wxFFile unless wxFile has large file support but wxFFile does not.
  29 //
  30 #if wxUSE_FFILE && (defined wxHAS_LARGE_FFILES || !defined wxHAS_LARGE_FILES)
  31 typedef wxFFile wxBFFile;
  32 static const bool wxBadSeek = false;
  33 #else
  34 typedef wxFile wxBFFile;
  35 static const wxFileOffset wxBadSeek = wxInvalidOffset;
  36 #endif
  37
  38 /////////////////////////////////////////////////////////////////////////////
  39 // Backing file implementation
  40
  41 class wxBackingFileImpl
  42 {
  43 public:
  44     wxBackingFileImpl(wxInputStream *stream,
  45                       size_t bufsize,
  46                       const wxString& prefix);
  47     ~wxBackingFileImpl();
  48
  49     void Release() { if (--m_refcount == 0) delete this; }
  50     wxBackingFileImpl *AddRef() { m_refcount++; return this; }
  51
  52     wxStreamError ReadAt(wxFileOffset pos, void *buffer, size_t *size);
  53     wxFileOffset GetLength() const;
  54
  55 private:
  56     int m_refcount;
  57
  58     wxInputStream *m_stream;
  59     wxStreamError m_parenterror;
  60
  61     char *m_buf;
  62     size_t m_bufsize;
  63     size_t m_buflen;
  64
  65     wxString m_prefix;
  66     wxString m_filename;
  67     wxBFFile m_file;
  68     wxFileOffset m_filelen;
  69 };
  70
  71 wxBackingFileImpl::wxBackingFileImpl(wxInputStream *stream,
  72                                      size_t bufsize,
  73                                      const wxString& prefix)
  74   : m_refcount(1),
  75     m_stream(stream),
  76     m_parenterror(wxSTREAM_NO_ERROR),
  77     m_buf(NULL),
  78     m_bufsize(bufsize),
  79     m_buflen(0),
  80     m_prefix(prefix),
  81     m_filelen(0)
  82 {
  83     wxFileOffset len = m_stream->GetLength();
  84
  85     if (len >= 0 && len + size_t(1) < m_bufsize)
  86         m_bufsize = size_t(len + 1);
  87
  88     if (m_bufsize)
  89         m_buf = new char[m_bufsize];
  90 }
  91
  92 wxBackingFileImpl::~wxBackingFileImpl()
  93 {
  94     delete m_stream;
  95     delete [] m_buf;
  96
  97     if (!m_filename.empty())
  98         wxRemoveFile(m_filename);
  99 }
 100
 101 wxStreamError wxBackingFileImpl::ReadAt(wxFileOffset pos,
 102                                         void *buffer,
 103                                         size_t *size)
 104 {
 105     size_t reqestedSize = *size;
 106     *size = 0;
 107
 108     // size1 is the number of bytes it will read directly from the backing
 109     // file. size2 is any remaining bytes not yet backed, these are returned
 110     // from the buffer or read from the parent stream.
 111     size_t size1, size2;
 112
 113     if (pos + reqestedSize <= m_filelen + size_t(0)) {
 114         size1 = reqestedSize;
 115         size2 = 0;
 116     } else if (pos < m_filelen) {
 117         size1 = size_t(m_filelen - pos);
 118         size2 = reqestedSize - size1;
 119     } else {
 120         size1 = 0;
 121         size2 = reqestedSize;
 122     }
 123
 124     if (pos < 0)
 125         return wxSTREAM_READ_ERROR;
 126
 127     // read the backing file
 128     if (size1) {
 129         if (m_file.Seek(pos) == wxBadSeek)
 130             return wxSTREAM_READ_ERROR;
 131
 132         ssize_t n = m_file.Read(buffer, size1);
 133         if (n > 0) {
 134             *size = n;
 135             pos += n;
 136         }
 137
 138         if (*size < size1)
 139             return wxSTREAM_READ_ERROR;
 140     }
 141
 142     // read from the buffer or parent stream
 143     if (size2)
 144     {
 145         while (*size < reqestedSize)
 146         {
 147             // if pos is further ahead than the parent has been read so far,
 148             // then read forward in the parent stream
 149             while (pos - m_filelen + size_t(0) >= m_buflen)
 150             {
 151                 // if the parent is small enough, don't use a backing file
 152                 // just the buffer memory
 153                 if (!m_stream && m_filelen == 0)
 154                     return m_parenterror;
 155
 156                 // before refilling the buffer write out the current buffer
 157                 // to the backing file if there is anything in it
 158                 if (m_buflen)
 159                 {
 160                     if (!m_file.IsOpened())
 161                         if (!wxCreateTempFile(m_prefix, &m_file, &m_filename))
 162                             return wxSTREAM_READ_ERROR;
 163
 164                     if (m_file.Seek(m_filelen) == wxBadSeek)
 165                         return wxSTREAM_READ_ERROR;
 166
 167                     size_t count = m_file.Write(m_buf, m_buflen);
 168                     m_filelen += count;
 169
 170                     if (count < m_buflen) {
 171                         delete m_stream;
 172                         m_stream = NULL;
 173                         if (count > 0) {
 174                             delete[] m_buf;
 175                             m_buf = NULL;
 176                             m_buflen = 0;
 177                         }
 178                         m_parenterror = wxSTREAM_READ_ERROR;
 179                         return m_parenterror;
 180                     }
 181
 182                     m_buflen = 0;
 183
 184                     if (!m_stream) {
 185                         delete[] m_buf;
 186                         m_buf = NULL;
 187                     }
 188                 }
 189
 190                 if (!m_stream)
 191                     return m_parenterror;
 192
 193                 // refill buffer
 194                 m_buflen = m_stream->Read(m_buf, m_bufsize).LastRead();
 195
 196                 if (m_buflen < m_bufsize) {
 197                     m_parenterror = m_stream->GetLastError();
 198                     if (m_parenterror == wxSTREAM_NO_ERROR)
 199                         m_parenterror = wxSTREAM_EOF;
 200                     delete m_stream;
 201                     m_stream = NULL;
 202                 }
 203             }
 204
 205             // copy to the user's buffer
 206             size_t start = size_t(pos - m_filelen);
 207             size_t len = wxMin(m_buflen - start, reqestedSize - *size);
 208
 209             memcpy((char*)buffer + *size, m_buf + start, len);
 210             *size += len;
 211             pos += len;
 212         }
 213     }
 214
 215     return wxSTREAM_NO_ERROR;
 216 }
 217
 218 wxFileOffset wxBackingFileImpl::GetLength() const
 219 {
 220     if (m_parenterror != wxSTREAM_EOF) {
 221         wxLogNull nolog;
 222         return m_stream->GetLength();
 223     }
 224     return m_filelen + m_buflen;
 225 }
 226
 227
 228 /////////////////////////////////////////////////////////////////////////////
 229 // Backing File, the handle part
 230
 231 wxBackingFile::wxBackingFile(wxInputStream *stream,
 232                              size_t bufsize,
 233                              const wxString& prefix)
 234   : m_impl(new wxBackingFileImpl(stream, bufsize, prefix))
 235 {
 236 }
 237
 238 wxBackingFile::wxBackingFile(const wxBackingFile& backer)
 239   : m_impl(backer.m_impl ? backer.m_impl->AddRef() : NULL)
 240 {
 241 }
 242
 243 wxBackingFile& wxBackingFile::operator=(const wxBackingFile& backer)
 244 {
 245     if (backer.m_impl != m_impl) {
 246         if (m_impl)
 247             m_impl->Release();
 248
 249         m_impl = backer.m_impl;
 250
 251         if (m_impl)
 252             m_impl->AddRef();
 253     }
 254
 255     return *this;
 256 }
 257
 258 wxBackingFile::~wxBackingFile()
 259 {
 260     if (m_impl)
 261         m_impl->Release();
 262 }
 263
 264
 265 /////////////////////////////////////////////////////////////////////////////
 266 // Input stream
 267
 268 wxBackedInputStream::wxBackedInputStream(const wxBackingFile& backer)
 269   : m_backer(backer),
 270     m_pos(0)
 271 {
 272 }
 273
 274 size_t wxBackedInputStream::OnSysRead(void *buffer, size_t size)
 275 {
 276     if (!IsOk())
 277         return 0;
 278
 279     m_lasterror = m_backer.m_impl->ReadAt(m_pos, buffer, &size);
 280     m_pos += size;
 281     return size;
 282 }
 283
 284 wxFileOffset wxBackedInputStream::GetLength() const
 285 {
 286     return m_backer.m_impl->GetLength();
 287 }
 288
 289 wxFileOffset wxBackedInputStream::OnSysSeek(wxFileOffset pos, wxSeekMode mode)
 290 {
 291     switch (mode) {
 292         case wxFromCurrent:
 293         {
 294             m_pos += pos;
 295             break;
 296         }
 297         case wxFromEnd:
 298         {
 299             wxFileOffset len = GetLength();
 300             if (len == wxInvalidOffset)
 301                 return wxInvalidOffset;
 302             m_pos = len + pos;
 303             break;
 304         }
 305         default:
 306         {
 307             m_pos = pos;
 308             break;
 309         }
 310     }
 311
 312     return m_pos;
 313 }
 314
 315 wxFileOffset wxBackedInputStream::OnSysTell() const
 316 {
 317     return m_pos;
 318 }
 319
 320 #endif // wxUSE_BACKINGFILE