Ignore:
Timestamp:
Jan 9, 2017, 11:09:38 AM (3 years ago)
Author:
jrpelegrina
Message:

Update new version: 3.15.02

File:
1 edited

Legend:

Unmodified
Added
Removed
  • filezilla/trunk/fuentes/src/engine/iothread.cpp

    r130 r3185  
    11#include <filezilla.h>
    22
    3 #include "file.h"
    43#include "iothread.h"
    54
     5#include <libfilezilla/file.hpp>
     6
    67#include <wx/log.h>
    78
    89CIOThread::CIOThread()
    9         : wxThread(wxTHREAD_JOINABLE)
    1010{
    1111        m_buffers[0] = new char[BUFFERSIZE*BUFFERCOUNT];
     
    2929                // so always truncate the file to the actually written size before closing it.
    3030                if (!m_read)
    31                         m_pFile->Truncate();
     31                        m_pFile->truncate();
    3232
    3333                m_pFile.reset();
     
    3535}
    3636
    37 bool CIOThread::Create(std::unique_ptr<CFile> && pFile, bool read, bool binary)
     37bool CIOThread::Create(std::unique_ptr<fz::file> && pFile, bool read, bool binary)
    3838{
    3939        wxASSERT(pFile);
     
    5555
    5656#ifdef SIMULATE_IO
    57         size_ = m_pFile->Length();
    58 #endif
    59 
     57        size_ = m_pFile->size();
     58#endif
     59       
    6060        m_running = true;
    61         wxThread::Create();
    62         wxThread::Run();
    63 
     61       
     62        if (!run()) {
     63                m_running = false;
     64                return false;
     65        }
     66       
    6467        return true;
    6568}
    6669
    67 wxThread::ExitCode CIOThread::Entry()
     70void CIOThread::entry()
    6871{
    6972        if (m_read) {
    7073                while (m_running) {
    71                         int len = ReadFromFile(m_buffers[m_curThreadBuf], BUFFERSIZE);
    72 
    73                         scoped_lock l(m_mutex);
     74                        auto len = ReadFromFile(m_buffers[m_curThreadBuf], BUFFERSIZE);
     75
     76                        fz::scoped_lock l(m_mutex);
    7477
    7578                        if (m_appWaiting) {
     
    7982                                }
    8083                                m_appWaiting = false;
    81                                 m_evtHandler->SendEvent<CIOThreadEvent>();
    82                         }
    83 
    84                         if (len == wxInvalidOffset) {
     84                                m_evtHandler->send_event<CIOThreadEvent>();
     85                        }
     86
     87                        if (len == -1) {
    8588                                m_error = true;
    8689                                m_running = false;
     
    107110        }
    108111        else {
    109                 scoped_lock l(m_mutex);
     112                fz::scoped_lock l(m_mutex);
    110113                while (m_curAppBuf == -1) {
    111114                        if (!m_running) {
    112                                 return 0;
     115                                return;
    113116                        }
    114117                        else {
     
    121124                        while (m_curThreadBuf == m_curAppBuf) {
    122125                                if (!m_running) {
    123                                         return 0;
     126                                        return;
    124127                                }
    125128                                m_threadWaiting = true;
     
    142145                                }
    143146                                m_appWaiting = false;
    144                                 m_evtHandler->SendEvent<CIOThreadEvent>();
     147                                m_evtHandler->send_event<CIOThreadEvent>();
    145148                        }
    146149
     
    151154                }
    152155        }
    153 
    154         return 0;
    155156}
    156157
    157158int CIOThread::GetNextWriteBuffer(char** pBuffer)
    158159{
    159         wxASSERT(!m_destroyed);
    160 
    161         scoped_lock l(m_mutex);
     160        fz::scoped_lock l(m_mutex);
    162161
    163162        if (m_error)
     
    191190        wxASSERT(m_pFile);
    192191
    193         if (m_destroyed)
    194                 return true;
    195 
    196192        Destroy();
    197193
     
    211207        if (!m_binary && m_wasCarriageReturn) {
    212208                const char CR = '\r';
    213                 if (m_pFile->Write(&CR, 1) != 1)
     209                if (m_pFile->write(&CR, 1) != 1)
    214210                        return false;
    215211        }
    216212#endif
     213
     214        m_curAppBuf = -1;
     215
    217216        return true;
    218217}
     
    220219int CIOThread::GetNextReadBuffer(char** pBuffer)
    221220{
    222         wxASSERT(!m_destroyed);
    223221        wxASSERT(m_read);
    224222
    225223        int newBuf = (m_curAppBuf + 1) % BUFFERCOUNT;
    226224
    227         scoped_lock l(m_mutex);
     225        fz::scoped_lock l(m_mutex);
    228226
    229227        if (newBuf == m_curThreadBuf) {
     
    251249void CIOThread::Destroy()
    252250{
    253         if (m_destroyed)
    254                 return;
    255         m_destroyed = true;
    256 
    257         scoped_lock l(m_mutex);
    258 
    259         m_running = false;
    260         if (m_threadWaiting) {
    261                 m_threadWaiting = false;
    262                 m_condition.signal(l);
    263         }
    264         l.unlock();
    265 
    266         Wait(wxTHREAD_WAIT_BLOCK);
    267 }
    268 
    269 int CIOThread::ReadFromFile(char* pBuffer, int maxLen)
     251        {
     252                fz::scoped_lock l(m_mutex);
     253                if (m_running) {
     254                        m_running = false;
     255                        if (m_threadWaiting) {
     256                                m_threadWaiting = false;
     257                                m_condition.signal(l);
     258                        }
     259                }
     260        }
     261
     262        join();
     263}
     264
     265int64_t CIOThread::ReadFromFile(char* pBuffer, int64_t maxLen)
    270266{
    271267#ifdef SIMULATE_IO
     
    283279        if (m_binary)
    284280#endif
    285                 return m_pFile->Read(pBuffer, maxLen);
     281                return m_pFile->read(pBuffer, maxLen);
    286282
    287283#ifndef __WXMSW__
     
    292288
    293289        char* r = pBuffer + readLen;
    294         int len = m_pFile->Read(r, readLen);
    295         if (!len || len == wxInvalidOffset)
     290        auto len = m_pFile->read(r, readLen);
     291        if (!len || len <= -1)
    296292                return len;
    297293
     
    319315}
    320316
    321 bool CIOThread::WriteToFile(char* pBuffer, int len)
     317bool CIOThread::WriteToFile(char* pBuffer, int64_t len)
    322318{
    323319#ifdef SIMULATE_IO
     
    334330        }
    335331        else {
     332
    336333                // On all CRLF pairs, omit the CR. Don't harm stand-alone CRs
    337                 // I assume disk access is buffered, otherwise the 1 byte writes are
    338                 // going to hurt performance.
    339                 const char CR = '\r';
     334
     335                // Handle trailing CR from last write
     336                if (m_wasCarriageReturn && len && *pBuffer != '\n' && *pBuffer != '\r') {
     337                        m_wasCarriageReturn = false;
     338                        const char CR = '\r';
     339                        if (!DoWrite(&CR, 1))
     340                                return false;
     341                }
     342
     343                // Skip forward to end of buffer or first CR
     344                const char* r = pBuffer;
    340345                const char* const end = pBuffer + len;
    341                 for (char* r = pBuffer; r != end; ++r) {
    342                         char c = *r;
    343                         if (c == '\r')
    344                                 m_wasCarriageReturn = true;
    345                         else if (c == '\n') {
    346                                 m_wasCarriageReturn = false;
    347                                 if (!DoWrite(&c, 1))
    348                                         return false;
    349                         }
    350                         else {
    351                                 if (m_wasCarriageReturn) {
     346                while (r != end && *r != '\r') {
     347                        ++r;
     348                }
     349
     350                if (r != end) {
     351                        // Now we gotta move data and also handle additional CRs.
     352                        m_wasCarriageReturn = true;
     353
     354                        char* w = const_cast<char*>(r++);
     355                        for (; r != end; ++r) {
     356                                if (*r == '\r') {
     357                                        m_wasCarriageReturn = true;
     358                                }
     359                                else if (*r == '\n') {
    352360                                        m_wasCarriageReturn = false;
    353                                         if (!DoWrite(&CR, 1))
    354                                                 return false;
    355                                 }
    356 
    357                                 if (!DoWrite(&c, 1))
    358                                         return false;
    359                         }
    360                 }
    361                 return true;
    362         }
    363 #endif
    364 }
    365 
    366 bool CIOThread::DoWrite(const char* pBuffer, int len)
    367 {
    368         int written = m_pFile->Write(pBuffer, len);
     361                                        *(w++) = *r;
     362                                }
     363                                else {
     364                                        if (m_wasCarriageReturn) {
     365                                                m_wasCarriageReturn = false;
     366                                                *(w++) = '\r';
     367                                        }
     368                                        *(w++) = *r;
     369                                }
     370                        }
     371                        len = w - pBuffer;
     372                }
     373                return DoWrite(pBuffer, len);
     374        }
     375#endif
     376}
     377
     378bool CIOThread::DoWrite(const char* pBuffer, int64_t len)
     379{
     380        auto written = m_pFile->write(pBuffer, len);
    369381        if (written == len) {
    370382                return true;
     
    375387        const wxString error = wxSysErrorMsg(code);
    376388
    377         scoped_lock locker(m_mutex);
     389        fz::scoped_lock locker(m_mutex);
    378390        m_error_description = error;
    379391
     
    383395wxString CIOThread::GetError()
    384396{
    385         scoped_lock locker(m_mutex);
     397        fz::scoped_lock locker(m_mutex);
    386398        return m_error_description;
    387399}
    388400
    389 void CIOThread::SetEventHandler(CEventHandler* handler)
    390 {
    391         scoped_lock locker(m_mutex);
     401void CIOThread::SetEventHandler(fz::event_handler* handler)
     402{
     403        fz::scoped_lock locker(m_mutex);
    392404        m_evtHandler = handler;
    393405}
Note: See TracChangeset for help on using the changeset viewer.