Index: src/ch/FeedbackHandler.h
===================================================================
diff -u -r22bbc4a87fa0b249e1e02ba385f28da9d77a4aa1 -rcac4819aa32d29c9feab400cadc083d713459a82
--- src/ch/FeedbackHandler.h (.../FeedbackHandler.h) (revision 22bbc4a87fa0b249e1e02ba385f28da9d77a4aa1)
+++ src/ch/FeedbackHandler.h (.../FeedbackHandler.h) (revision cac4819aa32d29c9feab400cadc083d713459a82)
@@ -66,7 +66,8 @@
eResult_Skip,
eResult_Cancel,
eResult_Pause,
- eResult_Retry
+ eResult_Retry,
+ eResult_Ignore
};
protected:
Index: src/ch/FeedbackNotEnoughSpaceDlg.cpp
===================================================================
diff -u -r22bbc4a87fa0b249e1e02ba385f28da9d77a4aa1 -rcac4819aa32d29c9feab400cadc083d713459a82
--- src/ch/FeedbackNotEnoughSpaceDlg.cpp (.../FeedbackNotEnoughSpaceDlg.cpp) (revision 22bbc4a87fa0b249e1e02ba385f28da9d77a4aa1)
+++ src/ch/FeedbackNotEnoughSpaceDlg.cpp (.../FeedbackNotEnoughSpaceDlg.cpp) (revision cac4819aa32d29c9feab400cadc083d713459a82)
@@ -158,7 +158,7 @@
void CFeedbackNotEnoughSpaceDlg::OnIgnoreButton()
{
UpdateData(TRUE);
- EndDialog(CFeedbackHandler::eResult_Skip);
+ EndDialog(CFeedbackHandler::eResult_Ignore);
}
void CFeedbackNotEnoughSpaceDlg::OnLanguageChanged()
Index: src/ch/task.cpp
===================================================================
diff -u -r95d37289059e4994adbe65aea90f30295e15317f -rcac4819aa32d29c9feab400cadc083d713459a82
--- src/ch/task.cpp (.../task.cpp) (revision 95d37289059e4994adbe65aea90f30295e15317f)
+++ src/ch/task.cpp (.../task.cpp) (revision cac4819aa32d29c9feab400cadc083d713459a82)
@@ -31,36 +31,6 @@
// assume max sectors of 4kB (for rounding)
#define MAXSECTORSIZE 4096
-///////////////////////////////////////////////////////////////////////
-// CProcessingException
-
-CProcessingException::CProcessingException(int iType, UINT uiFmtID, DWORD dwError, ...)
-{
- // std values
- m_iType=iType;
- m_dwError=dwError;
-
- // format some text
- CString strFormat = GetResManager().LoadString(uiFmtID);
- ExpandFormatString(&strFormat, dwError);
-
- // get param list
- va_list marker;
- va_start(marker, dwError);
- m_strErrorDesc.FormatV(strFormat, marker);
- va_end(marker);
-}
-
-CProcessingException::CProcessingException(int iType, DWORD dwError, const tchar_t* pszDesc)
-{
- // std values
- m_iType=iType;
- m_dwError=dwError;
-
- // format some text
- m_strErrorDesc = pszDesc;
-}
-
////////////////////////////////////////////////////////////////////////////////
// TTasksGlobalStats members
@@ -1215,7 +1185,7 @@
}
// searching for files
-void CTask::RecurseDirectories()
+CTask::ESubOperationResult CTask::RecurseDirectories()
{
// log
m_log.logi(_T("Searching for files..."));
@@ -1262,22 +1232,22 @@
switch(frResult)
{
case CFeedbackHandler::eResult_Cancel:
- throw new CProcessingException(E_CANCEL);
+ return eSubResult_CancelRequest;
case CFeedbackHandler::eResult_Retry:
bRetry = true;
break;
case CFeedbackHandler::eResult_Pause:
- throw new CProcessingException(E_PAUSE);
+ return eSubResult_PauseRequest;
case CFeedbackHandler::eResult_Skip:
bSkipInputPath = true;
break; // just do nothing
default:
BOOST_ASSERT(FALSE); // unknown result
- throw new CProcessingException(E_ERROR, 0, _t("Unknown feedback result type"));
+ THROW(_T("Unhandled case"), 0, 0, 0);
}
}
}
@@ -1341,7 +1311,7 @@
{
// log
m_log.logi(_T("Kill request while adding data to files array (RecurseDirectories)"));
- throw new CProcessingException(E_KILL_REQUEST);
+ return eSubResult_KillRequest;
}
}
else
@@ -1379,10 +1349,12 @@
// log
m_log.logi(_T("Searching for files finished"));
+
+ return eSubResult_Continue;
}
// delete files - after copying
-void CTask::DeleteFiles()
+CTask::ESubOperationResult CTask::DeleteFiles()
{
// log
m_log.logi(_T("Deleting files (DeleteFiles)..."));
@@ -1404,7 +1376,7 @@
{
// log
m_log.logi(_T("Kill request while deleting files (Delete Files)"));
- throw new CProcessingException(E_KILL_REQUEST);
+ return eSubResult_KillRequest;
}
// current processed element
@@ -1447,19 +1419,20 @@
{
case CFeedbackHandler::eResult_Cancel:
m_log.logi(_T("Cancel request while deleting file."));
- throw new CProcessingException(E_CANCEL);
- break;
+ return eSubResult_CancelRequest;
+
case CFeedbackHandler::eResult_Retry:
continue; // no stIndex bump, since we are trying again
- break;
+
case CFeedbackHandler::eResult_Pause:
- throw new CProcessingException(E_PAUSE);
- break;
+ return eSubResult_PauseRequest;
+
case CFeedbackHandler::eResult_Skip:
break; // just do nothing
+
default:
BOOST_ASSERT(FALSE); // unknown result
- throw new CProcessingException(E_ERROR, 0, _t("Unknown feedback result type"));
+ THROW(_T("Unhandled case"), 0, 0, 0);
}
}
@@ -1474,18 +1447,22 @@
// log
m_log.logi(_T("Deleting files finished"));
+
+ return eSubResult_Continue;
}
-HANDLE CTask::OpenSourceFileFB(const CFileInfoPtr& spSrcFileInfo, bool bNoBuffering)
+CTask::ESubOperationResult CTask::OpenSourceFileFB(TAutoFileHandle& hOutFile, const CFileInfoPtr& spSrcFileInfo, bool bNoBuffering)
{
BOOST_ASSERT(spSrcFileInfo);
if(!spSrcFileInfo)
THROW(_T("Invalid argument"), 0, 0, 0);
bool bRetry = false;
- HANDLE hFile = INVALID_HANDLE_VALUE;
CString strPath = spSrcFileInfo->GetFullFilePath();
+ hOutFile = INVALID_HANDLE_VALUE;
+
+ TAutoFileHandle hFile;
do
{
bRetry = false;
@@ -1511,11 +1488,12 @@
fmt.SetParam(_t("%errno"), dwLastError);
fmt.SetParam(_t("%path"), strPath);
m_log.loge(fmt);
- throw new CProcessingException(E_CANCEL);
+
+ return eSubResult_CancelRequest;
}
case CFeedbackHandler::eResult_Pause:
- throw new CProcessingException(E_PAUSE);
+ return eSubResult_PauseRequest;
case CFeedbackHandler::eResult_Retry:
{
@@ -1538,16 +1516,19 @@
}
while(bRetry);
- return hFile;
+ hOutFile = hFile.Detach();
+
+ return eSubResult_Continue;
}
-HANDLE CTask::OpenDestinationFileFB(const CString& strDstFilePath, bool bNoBuffering, const CFileInfoPtr& spSrcFileInfo, unsigned long long& ullSeekTo, bool& bFreshlyCreated)
+CTask::ESubOperationResult CTask::OpenDestinationFileFB(TAutoFileHandle& hOutFile, const CString& strDstFilePath, bool bNoBuffering, const CFileInfoPtr& spSrcFileInfo, unsigned long long& ullSeekTo, bool& bFreshlyCreated)
{
bool bRetry = false;
TAutoFileHandle hFile;
ullSeekTo = 0;
bFreshlyCreated = true;
+ hOutFile = INVALID_HANDLE_VALUE;
do
{
@@ -1562,9 +1543,11 @@
bFreshlyCreated = false;
// pass it to the specialized method
- hFile = OpenExistingDestinationFileFB(strDstFilePath, bNoBuffering);
- if(hFile == INVALID_HANDLE_VALUE)
- return hFile;
+ CTask::ESubOperationResult eResult = OpenExistingDestinationFileFB(hFile, strDstFilePath, bNoBuffering);
+ if(eResult != eSubResult_Continue)
+ return eResult;
+ else if(hFile == INVALID_HANDLE_VALUE)
+ return eSubResult_Continue;
// read info about the existing destination file,
// NOTE: it is not known which one would be faster - reading file parameters
@@ -1589,7 +1572,7 @@
break;
case CFeedbackHandler::eResult_Skip:
- return INVALID_HANDLE_VALUE;
+ return eSubResult_Continue;
case CFeedbackHandler::eResult_Cancel:
{
@@ -1599,10 +1582,10 @@
fmt.SetParam(_t("%path"), strDstFilePath);
m_log.logi(fmt);
- throw new CProcessingException(E_CANCEL);
+ return eSubResult_CancelRequest;
}
case CFeedbackHandler::eResult_Pause:
- throw new CProcessingException(E_PAUSE);
+ return eSubResult_PauseRequest;
default:
BOOST_ASSERT(FALSE); // unknown result
@@ -1638,14 +1621,14 @@
fmt.SetParam(_t("%path"), strDstFilePath);
m_log.loge(fmt);
- throw new CProcessingException(E_CANCEL);
+ return eSubResult_CancelRequest;
}
case CFeedbackHandler::eResult_Skip:
break; // will return invalid handle value
case CFeedbackHandler::eResult_Pause:
- throw new CProcessingException(E_PAUSE);
+ return eSubResult_PauseRequest;
default:
BOOST_ASSERT(FALSE); // unknown result
@@ -1656,15 +1639,18 @@
}
while(bRetry);
- return hFile.Detach();
+ hOutFile = hFile.Detach();
+ return eSubResult_Continue;
}
-HANDLE CTask::OpenExistingDestinationFileFB(const CString& strDstFilePath, bool bNoBuffering)
+CTask::ESubOperationResult CTask::OpenExistingDestinationFileFB(TAutoFileHandle& hOutFile, const CString& strDstFilePath, bool bNoBuffering)
{
bool bRetry = false;
- HANDLE hFile = INVALID_HANDLE_VALUE;
+ TAutoFileHandle hFile;
+ hOutFile = INVALID_HANDLE_VALUE;
+
do
{
bRetry = false;
@@ -1700,14 +1686,14 @@
fmt.SetParam(_t("%path"), strDstFilePath);
m_log.loge(fmt);
- throw new CProcessingException(E_CANCEL);
+ return eSubResult_CancelRequest;
}
case CFeedbackHandler::eResult_Skip:
break; // will return invalid handle value
case CFeedbackHandler::eResult_Pause:
- throw new CProcessingException(E_PAUSE);
+ return eSubResult_PauseRequest;
default:
BOOST_ASSERT(FALSE); // unknown result
@@ -1717,11 +1703,14 @@
}
while(bRetry);
- return hFile;
+ hOutFile = hFile.Detach();
+
+ return eSubResult_Continue;
}
-bool CTask::SetFilePointerFB(HANDLE hFile, long long llDistance, const CString& strFilePath)
+CTask::ESubOperationResult CTask::SetFilePointerFB(HANDLE hFile, long long llDistance, const CString& strFilePath, bool& bSkip)
{
+ bSkip = false;
bool bRetry = false;
do
{
@@ -1745,17 +1734,18 @@
switch(frResult)
{
case CFeedbackHandler::eResult_Cancel:
- throw new CProcessingException(E_CANCEL);
+ return eSubResult_CancelRequest;
case CFeedbackHandler::eResult_Retry:
bRetry = true;
break;
case CFeedbackHandler::eResult_Pause:
- throw new CProcessingException(E_PAUSE);
+ return eSubResult_PauseRequest;
case CFeedbackHandler::eResult_Skip:
- return false;
+ bSkip = true;
+ return eSubResult_Continue;
default:
BOOST_ASSERT(FALSE); // unknown result
@@ -1765,11 +1755,13 @@
}
while(bRetry);
- return true;
+ return eSubResult_Continue;
}
-bool CTask::SetEndOfFileFB(HANDLE hFile, const CString& strFilePath)
+CTask::ESubOperationResult CTask::SetEndOfFileFB(HANDLE hFile, const CString& strFilePath, bool& bSkip)
{
+ bSkip = false;
+
bool bRetry = false;
do
{
@@ -1789,16 +1781,17 @@
switch(frResult)
{
case CFeedbackHandler::eResult_Cancel:
- throw new CProcessingException(E_CANCEL);
+ return eSubResult_CancelRequest;
case CFeedbackHandler::eResult_Retry:
bRetry = true;
case CFeedbackHandler::eResult_Pause:
- throw new CProcessingException(E_PAUSE);
+ return eSubResult_PauseRequest;
case CFeedbackHandler::eResult_Skip:
- break; // just do nothing
+ bSkip = true;
+ return eSubResult_Continue;
default:
BOOST_ASSERT(FALSE); // unknown result
@@ -1808,11 +1801,12 @@
}
while(bRetry);
- return true;
+ return eSubResult_Continue;
}
-bool CTask::ReadFileFB(HANDLE hFile, CDataBuffer& rBuffer, DWORD dwToRead, DWORD& rdwBytesRead, const CString& strFilePath)
+CTask::ESubOperationResult CTask::ReadFileFB(HANDLE hFile, CDataBuffer& rBuffer, DWORD dwToRead, DWORD& rdwBytesRead, const CString& strFilePath, bool& bSkip)
{
+ bSkip = false;
bool bRetry = false;
do
{
@@ -1835,17 +1829,18 @@
switch(frResult)
{
case CFeedbackHandler::eResult_Cancel:
- throw new CProcessingException(E_CANCEL);
+ return eSubResult_CancelRequest;
case CFeedbackHandler::eResult_Retry:
bRetry = true;
break;
case CFeedbackHandler::eResult_Pause:
- throw new CProcessingException(E_PAUSE);
+ return eSubResult_PauseRequest;
case CFeedbackHandler::eResult_Skip:
- return false;
+ bSkip = true;
+ return eSubResult_Continue;
default:
BOOST_ASSERT(FALSE); // unknown result
@@ -1855,11 +1850,13 @@
}
while(bRetry);
- return true;
+ return eSubResult_Continue;
}
-bool CTask::WriteFileFB(HANDLE hFile, CDataBuffer& rBuffer, DWORD dwToWrite, DWORD& rdwBytesWritten, const CString& strFilePath)
+CTask::ESubOperationResult CTask::WriteFileFB(HANDLE hFile, CDataBuffer& rBuffer, DWORD dwToWrite, DWORD& rdwBytesWritten, const CString& strFilePath, bool& bSkip)
{
+ bSkip = false;
+
bool bRetry = false;
do
{
@@ -1882,17 +1879,18 @@
switch(frResult)
{
case CFeedbackHandler::eResult_Cancel:
- throw new CProcessingException(E_CANCEL);
+ return eSubResult_CancelRequest;
case CFeedbackHandler::eResult_Retry:
bRetry = true;
break;
case CFeedbackHandler::eResult_Pause:
- throw new CProcessingException(E_PAUSE);
+ return eSubResult_PauseRequest;
case CFeedbackHandler::eResult_Skip:
- return false;
+ bSkip = true;
+ return eSubResult_Continue;
default:
BOOST_ASSERT(FALSE); // unknown result
@@ -1902,14 +1900,16 @@
}
while(bRetry);
- return true;
+ return eSubResult_Continue;
}
-void CTask::CustomCopyFile(CUSTOM_COPY_PARAMS* pData)
+CTask::ESubOperationResult CTask::CustomCopyFile(CUSTOM_COPY_PARAMS* pData)
{
TAutoFileHandle hSrc = INVALID_HANDLE_VALUE,
- hDst = INVALID_HANDLE_VALUE;
+ hDst = INVALID_HANDLE_VALUE;
ictranslate::CFormat fmt;
+ CTask::ESubOperationResult eResult = eSubResult_Continue;
+ bool bSkip = false;
// calculate if we want to disable buffering for file transfer
// NOTE: we are using here the file size read when scanning directories for files; it might be
@@ -1918,13 +1918,15 @@
bool bNoBuffer = (GetConfig().get_bool(PP_BFUSENOBUFFERING) && pData->spSrcFile->GetLength64() >= (unsigned long long)GetConfig().get_signed_num(PP_BFBOUNDARYLIMIT));
// first open the source file and handle any failures
- hSrc = OpenSourceFileFB(pData->spSrcFile, bNoBuffer);
- if(hSrc == INVALID_HANDLE_VALUE)
+ eResult = OpenSourceFileFB(hSrc, pData->spSrcFile, bNoBuffer);
+ if(eResult != eSubResult_Continue)
+ return eResult;
+ else if(hSrc == INVALID_HANDLE_VALUE)
{
// invalid handle = operation skipped by user
m_localStats.IncreaseProcessedSize(pData->spSrcFile->GetLength64() - m_tTaskProgressInfo.GetCurrentFileProcessedSize());
pData->bProcessed = false;
- return;
+ return eSubResult_Continue;
}
// change attributes of a dest file
@@ -1941,23 +1943,27 @@
{
// open destination file for case, when we start operation on this file (i.e. it is not resume of the
// old operation)
- hDst = OpenDestinationFileFB(pData->strDstFile, bNoBuffer, pData->spSrcFile, ullSeekTo, bDstFileFreshlyCreated);
- if(hDst == INVALID_HANDLE_VALUE)
+ eResult = OpenDestinationFileFB(hDst, pData->strDstFile, bNoBuffer, pData->spSrcFile, ullSeekTo, bDstFileFreshlyCreated);
+ if(eResult != eSubResult_Continue)
+ return eResult;
+ else if(hDst == INVALID_HANDLE_VALUE)
{
m_localStats.IncreaseProcessedSize(pData->spSrcFile->GetLength64() - m_tTaskProgressInfo.GetCurrentFileProcessedSize());
pData->bProcessed = false;
- return;
+ return eSubResult_Continue;
}
}
else
{
// we are resuming previous operation
- hDst = OpenExistingDestinationFileFB(pData->strDstFile, bNoBuffer);
- if(hDst == INVALID_HANDLE_VALUE)
+ eResult = OpenExistingDestinationFileFB(hDst, pData->strDstFile, bNoBuffer);
+ if(eResult != eSubResult_Continue)
+ return eResult;
+ else if(hDst == INVALID_HANDLE_VALUE)
{
m_localStats.IncreaseProcessedSize(pData->spSrcFile->GetLength64() - m_tTaskProgressInfo.GetCurrentFileProcessedSize());
pData->bProcessed = false;
- return;
+ return eSubResult_Continue;
}
ullSeekTo = m_tTaskProgressInfo.GetCurrentFileProcessedSize();
@@ -1971,12 +1977,25 @@
// try to move file pointers to the end
ULONGLONG ullMove = (bNoBuffer ? ROUNDDOWN(ullSeekTo, MAXSECTORSIZE) : ullSeekTo);
- if(!SetFilePointerFB(hSrc, ullMove, pData->spSrcFile->GetFullFilePath()) || !SetFilePointerFB(hDst, ullMove, pData->strDstFile))
+ eResult = SetFilePointerFB(hSrc, ullMove, pData->spSrcFile->GetFullFilePath(), bSkip);
+ if(eResult != eSubResult_Continue)
+ return eResult;
+ else if(bSkip)
{
+ m_localStats.IncreaseProcessedSize(pData->spSrcFile->GetLength64() - m_tTaskProgressInfo.GetCurrentFileProcessedSize());
+ pData->bProcessed = false;
+ return eSubResult_Continue;
+ }
+
+ eResult = SetFilePointerFB(hDst, ullMove, pData->strDstFile, bSkip);
+ if(eResult != eSubResult_Continue)
+ return eResult;
+ else if(bSkip)
+ {
// with either first or second seek we got 'skip' answer...
m_localStats.IncreaseProcessedSize(pData->spSrcFile->GetLength64() - m_tTaskProgressInfo.GetCurrentFileProcessedSize());
pData->bProcessed = false;
- return;
+ return eSubResult_Continue;
}
m_tTaskProgressInfo.IncreaseCurrentFileProcessedSize(ullMove);
@@ -1987,10 +2006,13 @@
if(!bDstFileFreshlyCreated)
{
// if destination file was opened (as opposed to newly created)
- if(!SetEndOfFileFB(hDst, pData->strDstFile))
+ eResult = SetEndOfFileFB(hDst, pData->strDstFile, bSkip);
+ if(eResult != eSubResult_Continue)
+ return eResult;
+ else if(bSkip)
{
pData->bProcessed = false;
- return;
+ return eSubResult_Continue;
}
}
@@ -2011,7 +2033,7 @@
fmt.SetParam(_t("%srcpath"), pData->spSrcFile->GetFullFilePath());
fmt.SetParam(_t("%dstpath"), pData->strDstFile);
m_log.logi(fmt);
- throw new CProcessingException(E_KILL_REQUEST);
+ return eSubResult_KillRequest;
}
// recreate buffer if needed
@@ -2049,11 +2071,14 @@
ulToRead = bNoBuffer ? ROUNDUP(pData->dbBuffer.GetSizes()->m_auiSizes[iBufferIndex], MAXSECTORSIZE) : pData->dbBuffer.GetSizes()->m_auiSizes[iBufferIndex];
// read data from file to buffer
- if(!ReadFileFB(hSrc, pData->dbBuffer, ulToRead, ulRead, pData->spSrcFile->GetFullFilePath()))
+ eResult = ReadFileFB(hSrc, pData->dbBuffer, ulToRead, ulRead, pData->spSrcFile->GetFullFilePath(), bSkip);
+ if(eResult != eSubResult_Continue)
+ return eResult;
+ else if(bSkip)
{
m_localStats.IncreaseProcessedSize(pData->spSrcFile->GetLength64() - m_tTaskProgressInfo.GetCurrentFileProcessedSize());
pData->bProcessed = false;
- return;
+ return eSubResult_Continue;
}
if(ulRead > 0)
@@ -2072,11 +2097,14 @@
unsigned long ulDataToWrite = ROUNDDOWN(ulRead, MAXSECTORSIZE);
if(ulDataToWrite > 0)
{
- if(!WriteFileFB(hDst, pData->dbBuffer, ulDataToWrite, ulWritten, pData->strDstFile))
+ eResult = WriteFileFB(hDst, pData->dbBuffer, ulDataToWrite, ulWritten, pData->strDstFile, bSkip);
+ if(eResult != eSubResult_Continue)
+ return eResult;
+ else if(bSkip)
{
m_localStats.IncreaseProcessedSize(pData->spSrcFile->GetLength64() - m_tTaskProgressInfo.GetCurrentFileProcessedSize());
pData->bProcessed = false;
- return;
+ return eSubResult_Continue;
}
// increase count of processed data
@@ -2097,33 +2125,41 @@
if(ulRead != 0)
{
// re-open the destination file, this time with standard buffering to allow writing not aligned part of file data
- hDst = OpenExistingDestinationFileFB(pData->strDstFile, false);
- if(hDst == INVALID_HANDLE_VALUE)
+ eResult = OpenExistingDestinationFileFB(hDst, pData->strDstFile, false);
+ if(eResult != eSubResult_Continue)
+ return eResult;
+ else if(hDst == INVALID_HANDLE_VALUE)
{
m_localStats.IncreaseProcessedSize(pData->spSrcFile->GetLength64() - m_tTaskProgressInfo.GetCurrentFileProcessedSize());
pData->bProcessed = false;
- return;
+ return eSubResult_Continue;
}
// move file pointer to the end of destination file
- if(!SetFilePointerFB(hDst, m_tTaskProgressInfo.GetCurrentFileProcessedSize(), pData->strDstFile))
+ eResult = SetFilePointerFB(hDst, m_tTaskProgressInfo.GetCurrentFileProcessedSize(), pData->strDstFile, bSkip);
+ if(eResult != eSubResult_Continue)
+ return eResult;
+ else if(bSkip)
{
// with either first or second seek we got 'skip' answer...
m_localStats.IncreaseProcessedSize(pData->spSrcFile->GetLength64() - m_tTaskProgressInfo.GetCurrentFileProcessedSize());
pData->bProcessed = false;
- return;
+ return eSubResult_Continue;
}
}
}
// write
if(ulRead != 0)
{
- if(!WriteFileFB(hDst, pData->dbBuffer, ulRead, ulWritten, pData->strDstFile))
+ eResult = WriteFileFB(hDst, pData->dbBuffer, ulRead, ulWritten, pData->strDstFile, bSkip);
+ if(eResult != eSubResult_Continue)
+ return eResult;
+ else if(bSkip)
{
m_localStats.IncreaseProcessedSize(pData->spSrcFile->GetLength64() - m_tTaskProgressInfo.GetCurrentFileProcessedSize());
pData->bProcessed = false;
- return;
+ return eSubResult_Continue;
}
// increase count of processed data
@@ -2142,10 +2178,12 @@
pData->bProcessed = true;
m_tTaskProgressInfo.SetCurrentFileProcessedSize(0);
+
+ return eSubResult_Continue;
}
// function processes files/folders
-void CTask::ProcessFiles()
+CTask::ESubOperationResult CTask::ProcessFiles()
{
// log
m_log.logi(_T("Processing files/folders (ProcessFiles)"));
@@ -2194,7 +2232,7 @@
{
// log
m_log.logi(_T("Kill request while processing file in ProcessFiles"));
- throw new CProcessingException(E_KILL_REQUEST);
+ return eSubResult_KillRequest;
}
// update m_stCurrentIndex, getting current CFileInfo
@@ -2225,20 +2263,20 @@
switch(frResult)
{
case CFeedbackHandler::eResult_Cancel:
- throw new CProcessingException(E_CANCEL);
- break;
+ return eSubResult_CancelRequest;
+
case CFeedbackHandler::eResult_Retry:
continue;
- break;
+
case CFeedbackHandler::eResult_Pause:
- throw new CProcessingException(E_PAUSE);
- break;
+ return eSubResult_PauseRequest;
+
case CFeedbackHandler::eResult_Skip:
bRetry = false;
break; // just do nothing
default:
BOOST_ASSERT(FALSE); // unknown result
- throw new CProcessingException(E_ERROR, 0, _t("Unknown feedback result type"));
+ THROW(_T("Unhandled case"), 0, 0, 0);
}
}
else
@@ -2264,20 +2302,20 @@
switch(frResult)
{
case CFeedbackHandler::eResult_Cancel:
- throw new CProcessingException(E_CANCEL);
- break;
+ return eSubResult_CancelRequest;
+
case CFeedbackHandler::eResult_Retry:
continue;
- break;
+
case CFeedbackHandler::eResult_Pause:
- throw new CProcessingException(E_PAUSE);
- break;
+ return eSubResult_PauseRequest;
+
case CFeedbackHandler::eResult_Skip:
bRetry = false;
break; // just do nothing
default:
BOOST_ASSERT(FALSE); // unknown result
- throw new CProcessingException(E_ERROR, 0, _t("Unknown feedback result type"));
+ THROW(_T("Unhandled case"), 0, 0, 0);
}
}
@@ -2335,9 +2373,11 @@
}
// log
m_log.logi(_T("Finished processing in ProcessFiles"));
+
+ return eSubResult_Continue;
}
-void CTask::CheckForWaitState()
+CTask::ESubOperationResult CTask::CheckForWaitState()
{
// limiting operation count
SetTaskState(eTaskState_Waiting);
@@ -2360,11 +2400,67 @@
{
// log
m_log.logi(_T("Kill request while waiting for begin permission (wait state)"));
- throw new CProcessingException(E_KILL_REQUEST);
+ return eSubResult_KillRequest;
}
}
+
+ return eSubResult_Continue;
}
+CTask::ESubOperationResult CTask::CheckForFreeSpaceFB()
+{
+ ull_t ullNeededSize = 0, ullAvailableSize = 0;
+ bool bRetry = false;
+
+ do
+ {
+ bRetry = false;
+
+ m_log.logi(_T("Checking for free space on destination disk..."));
+
+ if(!GetRequiredFreeSpace(&ullNeededSize, &ullAvailableSize))
+ {
+ ictranslate::CFormat fmt;
+ fmt.SetFormat(_T("Not enough free space on disk - needed %needsize bytes for data, available: %availablesize bytes."));
+ fmt.SetParam(_t("%needsize"), ullNeededSize);
+ fmt.SetParam(_t("%availablesize"), ullAvailableSize);
+ m_log.logw(fmt);
+
+ if(GetClipboardDataSize() > 0)
+ {
+ CString strSrcPath = GetClipboardData(0)->GetPath();
+ CString strDstPath = GetDestPath().GetPath();
+ FEEDBACK_NOTENOUGHSPACE feedStruct = { ullNeededSize, (PCTSTR)strSrcPath, (PCTSTR)strDstPath };
+ CFeedbackHandler::EFeedbackResult frResult = (CFeedbackHandler::EFeedbackResult)m_piFeedbackHandler->RequestFeedback(CFeedbackHandler::eFT_NotEnoughSpace, &feedStruct);
+
+ // default
+ switch(frResult)
+ {
+ case CFeedbackHandler::eResult_Cancel:
+ m_log.logi(_T("Cancel request while checking for free space on disk."));
+ return eSubResult_CancelRequest;
+
+ case CFeedbackHandler::eResult_Retry:
+ m_log.logi(_T("Retrying to read drive's free space..."));
+ bRetry = true;
+ break;
+
+ case CFeedbackHandler::eResult_Ignore:
+ m_log.logi(_T("Ignored warning about not enough place on disk to copy data."));
+ return eSubResult_Continue;
+
+ default:
+ BOOST_ASSERT(FALSE); // unknown result
+ THROW(_T("Unhandled case"), 0, 0, 0);
+ }
+ }
+ }
+ }
+ while(bRetry);
+
+ return eSubResult_Continue;
+}
+
DWORD WINAPI CTask::DelegateThreadProc(LPVOID pParam)
{
BOOST_ASSERT(pParam);
@@ -2377,189 +2473,153 @@
DWORD CTask::ThrdProc()
{
- tstring_t strPath = GetTaskPath();
- strPath += GetUniqueName()+_T(".log");
+ try
+ {
+ CTask::ESubOperationResult eResult = eSubResult_Continue;
- m_log.init(strPath.c_str(), 262144, icpf::log_file::level_debug, false, false);
+ // initialize log file
+ tstring_t strPath = GetTaskPath();
+ strPath += GetUniqueName()+_T(".log");
- OnBeginOperation();
+ m_log.init(strPath.c_str(), 262144, icpf::log_file::level_debug, false, false);
- // set thread boost
- HANDLE hThread=GetCurrentThread();
- ::SetThreadPriorityBoost(hThread, GetConfig().get_bool(PP_CMDISABLEPRIORITYBOOST));
+ // start operation
+ OnBeginOperation();
- ictranslate::CFormat fmt;
- try
- {
- // to make the value stable
+ // set thread options
+ HANDLE hThread = GetCurrentThread();
+ ::SetThreadPriorityBoost(hThread, GetConfig().get_bool(PP_CMDISABLEPRIORITYBOOST));
+
+ // determine when to scan directories
bool bReadTasksSize = GetConfig().get_bool(PP_CMREADSIZEBEFOREBLOCKING);
+ // check if we're allowed to continue searching for files
if(!bReadTasksSize)
- CheckForWaitState(); // operation limiting
+ eResult = CheckForWaitState(); // operation limiting
// start tracking time
- m_localStats.EnableTimeTracking();
-
- // search for files if needed
- if((GetStatus(ST_STEP_MASK) == ST_NULL_STATUS || GetStatus(ST_STEP_MASK) == ST_SEARCHING))
+ if(eResult == eSubResult_Continue)
{
- // get rid of info about processed sizes
- m_localStats.SetProcessedSize(0);
- m_localStats.SetTotalSize(0);
+ m_localStats.EnableTimeTracking();
- // start searching
- RecurseDirectories();
- }
-
- // check for free space
- ull_t ullNeededSize = 0, ullAvailableSize = 0;
- bool bRetry = false;
-
- do
- {
- bRetry = false;
-
- m_log.logi(_T("Checking for free space on destination disk..."));
-
- if(!GetRequiredFreeSpace(&ullNeededSize, &ullAvailableSize))
+ // search for files if needed
+ if((GetStatus(ST_STEP_MASK) == ST_NULL_STATUS || GetStatus(ST_STEP_MASK) == ST_SEARCHING))
{
- fmt.SetFormat(_T("Not enough free space on disk - needed %needsize bytes for data, available: %availablesize bytes."));
- fmt.SetParam(_t("%needsize"), ullNeededSize);
- fmt.SetParam(_t("%availablesize"), ullAvailableSize);
- m_log.logw(fmt);
+ // get rid of info about processed sizes
+ m_localStats.SetProcessedSize(0);
+ m_localStats.SetTotalSize(0);
- if(GetClipboardDataSize() > 0)
- {
- CString strSrcPath = GetClipboardData(0)->GetPath();
- CString strDstPath = GetDestPath().GetPath();
- FEEDBACK_NOTENOUGHSPACE feedStruct = { ullNeededSize, (PCTSTR)strSrcPath, (PCTSTR)strDstPath };
- CFeedbackHandler::EFeedbackResult frResult = (CFeedbackHandler::EFeedbackResult)m_piFeedbackHandler->RequestFeedback(CFeedbackHandler::eFT_NotEnoughSpace, &feedStruct);
-
- // default
- switch (frResult)
- {
- case CFeedbackHandler::eResult_Cancel:
- {
- m_log.logi(_T("Cancel request while checking for free space on disk."));
- throw new CProcessingException(E_CANCEL);
- break;
- }
- case CFeedbackHandler::eResult_Retry:
- m_log.logi(_T("Retrying to read drive's free space..."));
- bRetry = true;
- break;
- case CFeedbackHandler::eResult_Skip:
- m_log.logi(_T("Ignored warning about not enough place on disk to copy data."));
- break;
- default:
- BOOST_ASSERT(FALSE); // unknown result
- throw new CProcessingException(E_ERROR, 0, _t("Unknown feedback result type"));
- break;
- }
- }
+ // start searching
+ eResult = RecurseDirectories();
}
}
- while(bRetry);
- if(bReadTasksSize)
+ // check for free space
+ if(eResult == eSubResult_Continue)
+ eResult = CheckForFreeSpaceFB();
+
+ if(eResult == eSubResult_Continue && bReadTasksSize)
{
m_localStats.DisableTimeTracking();
- CheckForWaitState();
+ eResult = CheckForWaitState();
m_localStats.EnableTimeTracking();
}
// Phase II - copying/moving
- if(GetStatus(ST_STEP_MASK) == ST_COPYING)
+ if(eResult == eSubResult_Continue && GetStatus(ST_STEP_MASK) == ST_COPYING)
{
// decrease processed in ctaskarray - the rest will be done in ProcessFiles
//m_rtGlobalStats.DecreaseGlobalProcessedSize(GetProcessedSize());
- ProcessFiles();
+ eResult = ProcessFiles();
}
// deleting data - III phase
- if(GetStatus(ST_STEP_MASK) == ST_DELETING)
- DeleteFiles();
+ if(eResult == eSubResult_Continue && GetStatus(ST_STEP_MASK) == ST_DELETING)
+ eResult = DeleteFiles();
// refresh time
m_localStats.DisableTimeTracking();
- // save progress before killed
- Store(false);
-
- // we are ending
- m_localStats.MarkTaskAsNotRunning();
-
- // play sound
- m_piFeedbackHandler->RequestFeedback(CFeedbackHandler::eFT_OperationFinished, NULL);
-
- OnEndOperation();
- }
- catch(CProcessingException* e)
- {
- // refresh time
- m_localStats.DisableTimeTracking();
-
- // log
- fmt.SetFormat(_T("Caught exception in ThrdProc [last error: %errno, type: %type]"));
- fmt.SetParam(_t("%errno"), e->m_dwError);
- fmt.SetParam(_t("%type"), e->m_iType);
- m_log.loge(fmt);
-
- if(e->m_iType == E_ERROR)
- m_piFeedbackHandler->RequestFeedback(CFeedbackHandler::eFT_OperationError, NULL);
-
- // perform some adjustments depending on exception type
- switch(e->m_iType)
+ // finishing processing
+ // change task status
+ switch(eResult)
{
- case E_ERROR:
+ case eSubResult_Error:
+ m_piFeedbackHandler->RequestFeedback(CFeedbackHandler::eFT_OperationError, NULL);
SetTaskState(eTaskState_Error);
break;
- case E_CANCEL:
+
+ case eSubResult_CancelRequest:
SetTaskState(eTaskState_Cancelled);
break;
- case E_PAUSE:
+
+ case eSubResult_PauseRequest:
SetTaskState(eTaskState_Paused);
break;
- case E_KILL_REQUEST:
- {
- // the only operation
- if(GetTaskState() == eTaskState_Waiting)
- SetTaskState(eTaskState_Processing);
- }
+
+ case eSubResult_KillRequest:
+ // the only operation
+ if(GetTaskState() == eTaskState_Waiting)
+ SetTaskState(eTaskState_Processing);
+ break;
+
+ case eSubResult_Continue:
+ m_piFeedbackHandler->RequestFeedback(CFeedbackHandler::eFT_OperationFinished, NULL);
+ SetTaskState(eTaskState_Finished);
+ break;
+
default:
- BOOST_ASSERT(false); // unhandled case
+ BOOST_ASSERT(false);
+ THROW(_T("Unhandled case"), 0, 0, 0);
}
- // change flags and calls cleanup for a task
+ // perform cleanup dependent on currently executing subtask
switch(GetStatus(ST_STEP_MASK))
{
case ST_NULL_STATUS:
case ST_SEARCHING:
- // get rid of m_files contents
- m_files.Clear();
-
- // save state of a task
- Store(true);
- Store(false);
-
+ m_files.Clear(); // get rid of m_files contents
+ Store(true); // save state of a task
break;
- case ST_COPYING:
- case ST_DELETING:
- Store(false);
- break;
}
- m_localStats.MarkTaskAsNotRunning();
+ // save progress before killed
+ Store(false);
+
+ // reset flags
SetContinueFlag(false);
SetForceFlag(false);
+ // mark this task as dead, so other can start
+ m_localStats.MarkTaskAsNotRunning();
+
+ // and the real end
OnEndOperation();
+ }
+ catch(...)
+ {
+ // refresh time
+ m_localStats.DisableTimeTracking();
- delete e;
+ // log
+ ictranslate::CFormat fmt;
- return 0xffffffff; // almost like -1
+ fmt.SetFormat(_T("Caught exception in ThrdProc"));
+ m_log.loge(fmt);
+
+ // let others know some error happened
+ m_piFeedbackHandler->RequestFeedback(CFeedbackHandler::eFT_OperationError, NULL);
+ SetTaskState(eTaskState_Error);
+
+ m_localStats.MarkTaskAsNotRunning();
+
+ SetContinueFlag(false);
+ SetForceFlag(false);
+
+ OnEndOperation();
+ return 1;
}
return 0;
Index: src/ch/task.h
===================================================================
diff -u -r4cd45795025411a82006a94d9c7f7f2d9ecda421 -rcac4819aa32d29c9feab400cadc083d713459a82
--- src/ch/task.h (.../task.h) (revision 4cd45795025411a82006a94d9c7f7f2d9ecda421)
+++ src/ch/task.h (.../task.h) (revision cac4819aa32d29c9feab400cadc083d713459a82)
@@ -45,6 +45,7 @@
#define ST_IGNORE_CONTENT 0x00002000
#define ST_FORCE_DIRS 0x00004000
+// enum representing current processing state of the task
enum ETaskCurrentState
{
eTaskState_None,
@@ -59,20 +60,13 @@
eTaskState_Max
};
+// enum represents type of the operation handled by the task
enum EOperationType
{
eOperation_Copy,
eOperation_Move
};
-///////////////////////////////////////////////////////////////////////////
-// Exceptions
-
-#define E_KILL_REQUEST 0x00
-#define E_ERROR 0x01
-#define E_CANCEL 0x02
-#define E_PAUSE 0x03
-
// special value representing no task
#define NO_TASK_SESSION_UNIQUE_ID 0
@@ -371,6 +365,17 @@
// CTask
class CTask
{
+protected:
+ // enum using internally by the CTask class to pass the operation results between methods
+ enum ESubOperationResult
+ {
+ eSubResult_Continue,
+ eSubResult_KillRequest,
+ eSubResult_Error,
+ eSubResult_CancelRequest,
+ eSubResult_PauseRequest
+ };
+
public:
CTask(chcore::IFeedbackHandler* piFeedbackHandler, size_t stSessionUniqueID);
~CTask();
@@ -454,31 +459,33 @@
/// Main function for the task processing thread
DWORD WINAPI ThrdProc();
- void RecurseDirectories();
+ ESubOperationResult RecurseDirectories();
int ScanDirectory(CString strDirName, size_t stSrcIndex, bool bRecurse, bool bIncludeDirs);
- void ProcessFiles();
- void CustomCopyFile(CUSTOM_COPY_PARAMS* pData);
+ ESubOperationResult ProcessFiles();
+ ESubOperationResult CustomCopyFile(CUSTOM_COPY_PARAMS* pData);
- void DeleteFiles();
+ ESubOperationResult DeleteFiles();
- void CheckForWaitState();
+ ESubOperationResult CheckForWaitState();
// Helper filesystem methods
static bool SetFileDirectoryTime(LPCTSTR lpszName, const CFileInfoPtr& spFileInfo);
bool GetRequiredFreeSpace(ull_t *pi64Needed, ull_t *pi64Available);
- HANDLE OpenSourceFileFB(const CFileInfoPtr& spSrcFileInfo, bool bNoBuffering);
- HANDLE OpenDestinationFileFB(const CString& strDstFilePath, bool bNoBuffering, const CFileInfoPtr& spSrcFileInfo, unsigned long long& ullSeekTo, bool& bFreshlyCreated);
- HANDLE OpenExistingDestinationFileFB(const CString& strDstFilePath, bool bNoBuffering);
+ ESubOperationResult OpenSourceFileFB(TAutoFileHandle& hFile, const CFileInfoPtr& spSrcFileInfo, bool bNoBuffering);
+ ESubOperationResult OpenDestinationFileFB(TAutoFileHandle& hFile, const CString& strDstFilePath, bool bNoBuffering, const CFileInfoPtr& spSrcFileInfo, unsigned long long& ullSeekTo, bool& bFreshlyCreated);
+ ESubOperationResult OpenExistingDestinationFileFB(TAutoFileHandle& hFile, const CString& strDstFilePath, bool bNoBuffering);
- bool SetFilePointerFB(HANDLE hFile, long long llDistance, const CString& strFilePath);
- bool SetEndOfFileFB(HANDLE hFile, const CString& strFilePath);
+ ESubOperationResult SetFilePointerFB(HANDLE hFile, long long llDistance, const CString& strFilePath, bool& bSkip);
+ ESubOperationResult SetEndOfFileFB(HANDLE hFile, const CString& strFilePath, bool& bSkip);
- bool ReadFileFB(HANDLE hFile, CDataBuffer& rBuffer, DWORD dwToRead, DWORD& rdwBytesRead, const CString& strFilePath);
- bool WriteFileFB(HANDLE hFile, CDataBuffer& rBuffer, DWORD dwToWrite, DWORD& rdwBytesWritten, const CString& strFilePath);
+ ESubOperationResult ReadFileFB(HANDLE hFile, CDataBuffer& rBuffer, DWORD dwToRead, DWORD& rdwBytesRead, const CString& strFilePath, bool& bSkip);
+ ESubOperationResult WriteFileFB(HANDLE hFile, CDataBuffer& rBuffer, DWORD dwToWrite, DWORD& rdwBytesWritten, const CString& strFilePath, bool& bSkip);
+ ESubOperationResult CheckForFreeSpaceFB();
+
int GetDestDriveNumber();
// m_nStatus
@@ -569,24 +576,6 @@
typedef boost::shared_ptr<CTask> CTaskPtr;
///////////////////////////////////////////////////////////////////////////
-// CProcessingException
-
-class CProcessingException
-{
-public:
- CProcessingException(int iType) { m_iType=iType; m_dwError=0; };
- CProcessingException(int iType, UINT uiFmtID, DWORD dwError, ...);
- CProcessingException(int iType, DWORD dwError, const tchar_t* pszDesc);
-
- // Implementation
-public:
- int m_iType; // kill request, error, ...
-
- CString m_strErrorDesc;
- DWORD m_dwError;
-};
-
-///////////////////////////////////////////////////////////////////////////
// CTaskArray
class CTaskArray