Index: src/libchcore/TSubTaskArray.cpp =================================================================== diff -u -N -r7972b0944e0a947144fbdb93262f7d73ac528dc7 -re96806b7f8ff7ca7e9f4afbea603e6351a3dc3e3 --- src/libchcore/TSubTaskArray.cpp (.../TSubTaskArray.cpp) (revision 7972b0944e0a947144fbdb93262f7d73ac528dc7) +++ src/libchcore/TSubTaskArray.cpp (.../TSubTaskArray.cpp) (revision e96806b7f8ff7ca7e9f4afbea603e6351a3dc3e3) @@ -35,54 +35,54 @@ #include "ErrorCodes.h" #include -BEGIN_CHCORE_NAMESPACE - -/////////////////////////////////////////////////////////////////////////// -// TSubTasksArray - -TSubTasksArray::TSubTasksArray(TSubTaskContext& rSubTaskContext) : - m_rSubTaskContext(rSubTaskContext), - m_eOperationType(m_setModifications, eOperation_None), - m_oidSubOperationIndex(0), - m_oidLastStoredIndex((object_id_t)-1) +namespace chcore { - m_setModifications[eMod_Added] = true; -} + /////////////////////////////////////////////////////////////////////////// + // TSubTasksArray -TSubTasksArray::TSubTasksArray(const TOperationPlan& rOperationPlan, TSubTaskContext& rSubTaskContext) : - m_rSubTaskContext(rSubTaskContext), - m_eOperationType(m_setModifications, eOperation_None), - m_oidSubOperationIndex(0), - m_oidLastStoredIndex((object_id_t)-1) -{ - m_setModifications[eMod_Added] = true; - Init(rOperationPlan); -} + TSubTasksArray::TSubTasksArray(TSubTaskContext& rSubTaskContext) : + m_rSubTaskContext(rSubTaskContext), + m_eOperationType(m_setModifications, eOperation_None), + m_oidSubOperationIndex(0), + m_oidLastStoredIndex((object_id_t)-1) + { + m_setModifications[eMod_Added] = true; + } -TSubTasksArray::~TSubTasksArray() -{ -} + TSubTasksArray::TSubTasksArray(const TOperationPlan& rOperationPlan, TSubTaskContext& rSubTaskContext) : + m_rSubTaskContext(rSubTaskContext), + m_eOperationType(m_setModifications, eOperation_None), + m_oidSubOperationIndex(0), + m_oidLastStoredIndex((object_id_t)-1) + { + m_setModifications[eMod_Added] = true; + Init(rOperationPlan); + } -void TSubTasksArray::Init(const TOperationPlan& rOperationPlan) -{ - m_vSubTasks.clear(); - m_rSubTaskContext.GetFilesCache().Clear(); - m_oidSubOperationIndex.store(0, std::memory_order_release); + TSubTasksArray::~TSubTasksArray() + { + } - m_eOperationType = rOperationPlan.GetOperationType(); - - switch(m_eOperationType) + void TSubTasksArray::Init(const TOperationPlan& rOperationPlan) { - case eOperation_Copy: + m_vSubTasks.clear(); + m_rSubTaskContext.GetFilesCache().Clear(); + m_oidSubOperationIndex.store(0, std::memory_order_release); + + m_eOperationType = rOperationPlan.GetOperationType(); + + switch (m_eOperationType) { + case eOperation_Copy: + { TSubTaskBasePtr spOperation = boost::make_shared(boost::ref(m_rSubTaskContext)); AddSubTask(spOperation, true); spOperation = boost::make_shared(boost::ref(m_rSubTaskContext)); AddSubTask(spOperation, false); break; } - case eOperation_Move: + case eOperation_Move: { TSubTaskBasePtr spOperation = boost::make_shared(boost::ref(m_rSubTaskContext)); AddSubTask(spOperation, true); @@ -95,262 +95,261 @@ break; } - default: - THROW_CORE_EXCEPTION(eErr_UndefinedOperation); + default: + THROW_CORE_EXCEPTION(eErr_UndefinedOperation); + } } -} -void TSubTasksArray::ResetProgressAndStats() -{ - m_oidSubOperationIndex.store(0, std::memory_order_release); - - for(const std::pair& tupleRow : m_vSubTasks) + void TSubTasksArray::ResetProgressAndStats() { - if(tupleRow.first == NULL) - THROW_CORE_EXCEPTION(eErr_InternalProblem); + m_oidSubOperationIndex.store(0, std::memory_order_release); - tupleRow.first->Reset(); + for (const std::pair& tupleRow : m_vSubTasks) + { + if (tupleRow.first == NULL) + THROW_CORE_EXCEPTION(eErr_InternalProblem); + + tupleRow.first->Reset(); + } } -} -TSubTaskBase::ESubOperationResult TSubTasksArray::Execute(const IFeedbackHandlerPtr& spFeedbackHandler, bool bRunOnlyEstimationSubTasks) -{ - TSubTaskBase::ESubOperationResult eResult = TSubTaskBase::eSubResult_Continue; - - object_id_t oidSize = boost::numeric_cast(m_vSubTasks.size()); - object_id_t oidIndex = m_oidSubOperationIndex.load(std::memory_order_acquire); - - while(oidIndex < oidSize) + TSubTaskBase::ESubOperationResult TSubTasksArray::Execute(const IFeedbackHandlerPtr& spFeedbackHandler, bool bRunOnlyEstimationSubTasks) { - std::pair& rCurrentSubTask = m_vSubTasks.at(boost::numeric_cast(oidIndex)); - TSubTaskBasePtr spCurrentSubTask = rCurrentSubTask.first; + TSubTaskBase::ESubOperationResult eResult = TSubTaskBase::eSubResult_Continue; - // if we run in estimation mode only, then stop processing and return to the caller - if(bRunOnlyEstimationSubTasks && !rCurrentSubTask.second) + object_id_t oidSize = boost::numeric_cast(m_vSubTasks.size()); + object_id_t oidIndex = m_oidSubOperationIndex.load(std::memory_order_acquire); + + while (oidIndex < oidSize) { - eResult = TSubTaskBase::eSubResult_Continue; - break; - } + std::pair& rCurrentSubTask = m_vSubTasks.at(boost::numeric_cast(oidIndex)); + TSubTaskBasePtr spCurrentSubTask = rCurrentSubTask.first; - eResult = spCurrentSubTask->Exec(spFeedbackHandler); - if(eResult != TSubTaskBase::eSubResult_Continue) - break; + // if we run in estimation mode only, then stop processing and return to the caller + if (bRunOnlyEstimationSubTasks && !rCurrentSubTask.second) + { + eResult = TSubTaskBase::eSubResult_Continue; + break; + } - oidIndex = m_oidSubOperationIndex.fetch_add(1, std::memory_order_release) + 1; - } + eResult = spCurrentSubTask->Exec(spFeedbackHandler); + if (eResult != TSubTaskBase::eSubResult_Continue) + break; - return eResult; -} + oidIndex = m_oidSubOperationIndex.fetch_add(1, std::memory_order_release) + 1; + } -void TSubTasksArray::AddSubTask(const TSubTaskBasePtr& spOperation, bool bIsPartOfEstimation) -{ - m_vSubTasks.push_back(std::make_pair(spOperation, bIsPartOfEstimation)); -} + return eResult; + } -void TSubTasksArray::GetStatsSnapshot(TSubTaskArrayStatsSnapshot& rSnapshot) const -{ - rSnapshot.Clear(); + void TSubTasksArray::AddSubTask(const TSubTaskBasePtr& spOperation, bool bIsPartOfEstimation) + { + m_vSubTasks.push_back(std::make_pair(spOperation, bIsPartOfEstimation)); + } - // current task - // ugly const_cast - const method, non-const interlocked intrinsic and we're really not modifying the member... - object_id_t oidIndex = m_oidSubOperationIndex.load(std::memory_order_acquire); - rSnapshot.SetCurrentSubtaskIndex(oidIndex); - - // progress - for(size_t stSubOperationIndex = 0; stSubOperationIndex < m_vSubTasks.size(); ++stSubOperationIndex) + void TSubTasksArray::GetStatsSnapshot(TSubTaskArrayStatsSnapshot& rSnapshot) const { - const std::pair& rCurrentSubTask = m_vSubTasks[stSubOperationIndex]; - TSubTaskBasePtr spCurrentSubTask = rCurrentSubTask.first; + rSnapshot.Clear(); - TSubTaskStatsSnapshotPtr spSubtaskSnapshot(new TSubTaskStatsSnapshot); + // current task + // ugly const_cast - const method, non-const interlocked intrinsic and we're really not modifying the member... + object_id_t oidIndex = m_oidSubOperationIndex.load(std::memory_order_acquire); + rSnapshot.SetCurrentSubtaskIndex(oidIndex); - spCurrentSubTask->GetStatsSnapshot(spSubtaskSnapshot); - rSnapshot.AddSubTaskSnapshot(spSubtaskSnapshot); - } -} + // progress + for (size_t stSubOperationIndex = 0; stSubOperationIndex < m_vSubTasks.size(); ++stSubOperationIndex) + { + const std::pair& rCurrentSubTask = m_vSubTasks[stSubOperationIndex]; + TSubTaskBasePtr spCurrentSubTask = rCurrentSubTask.first; -EOperationType TSubTasksArray::GetOperationType() const -{ - return m_eOperationType; -} + TSubTaskStatsSnapshotPtr spSubtaskSnapshot(new TSubTaskStatsSnapshot); -void TSubTasksArray::Store(const ISerializerPtr& spSerializer) const -{ - bool bAdded = m_setModifications[eMod_Added]; + spCurrentSubTask->GetStatsSnapshot(spSubtaskSnapshot); + rSnapshot.AddSubTaskSnapshot(spSubtaskSnapshot); + } + } - /////////////////////////////////////////////////////////////////////// - if (m_eOperationType.IsModified()) + EOperationType TSubTasksArray::GetOperationType() const { - ISerializerContainerPtr spContainer = spSerializer->GetContainer(_T("subtasks_info")); - InitSubtasksInfoColumns(spContainer); - - ISerializerRowData& rRow = spContainer->GetRow(0, bAdded); - - rRow.SetValue(_T("operation"), m_eOperationType.Get()); + return m_eOperationType; } - /////////////////////////////////////////////////////////////////////// + void TSubTasksArray::Store(const ISerializerPtr& spSerializer) const { - ISerializerContainerPtr spContainer = spSerializer->GetContainer(_T("subtasks")); - InitSubtasksColumns(spContainer); + bool bAdded = m_setModifications[eMod_Added]; - // base data - object_id_t oidCurrentIndex = m_oidSubOperationIndex.load(std::memory_order_acquire); - - // subtasks are stored only once when added as they don't change (at least in context of their order and type) - if(bAdded) + /////////////////////////////////////////////////////////////////////// + if (m_eOperationType.IsModified()) { - if(m_oidLastStoredIndex != -1) - THROW_CORE_EXCEPTION(eErr_InternalProblem); + ISerializerContainerPtr spContainer = spSerializer->GetContainer(_T("subtasks_info")); + InitSubtasksInfoColumns(spContainer); - for(size_t stSubOperationIndex = 0; stSubOperationIndex < m_vSubTasks.size(); ++stSubOperationIndex) - { - const std::pair& rCurrentSubTask = m_vSubTasks[stSubOperationIndex]; + ISerializerRowData& rRow = spContainer->GetRow(0, bAdded); - ISerializerRowData& rRow = spContainer->GetRow(boost::numeric_cast(stSubOperationIndex), bAdded); - rRow.SetValue(_T("type"), rCurrentSubTask.first->GetSubOperationType()); - rRow.SetValue(_T("is_current"), false); - rRow.SetValue(_T("is_estimation"), rCurrentSubTask.second); - } + rRow.SetValue(_T("operation"), m_eOperationType.Get()); } - // serialize current index - if(bAdded || oidCurrentIndex != m_oidLastStoredIndex) + /////////////////////////////////////////////////////////////////////// { - // mark subtask at current index as "current"; don't do that if we just finished. - if(boost::numeric_cast(oidCurrentIndex) != m_vSubTasks.size()) + ISerializerContainerPtr spContainer = spSerializer->GetContainer(_T("subtasks")); + InitSubtasksColumns(spContainer); + + // base data + object_id_t oidCurrentIndex = m_oidSubOperationIndex.load(std::memory_order_acquire); + + // subtasks are stored only once when added as they don't change (at least in context of their order and type) + if (bAdded) { - ISerializerRowData& rRow = spContainer->GetRow(oidCurrentIndex, false); - rRow.SetValue(_T("is_current"), true); + if (m_oidLastStoredIndex != -1) + THROW_CORE_EXCEPTION(eErr_InternalProblem); + + for (size_t stSubOperationIndex = 0; stSubOperationIndex < m_vSubTasks.size(); ++stSubOperationIndex) + { + const std::pair& rCurrentSubTask = m_vSubTasks[stSubOperationIndex]; + + ISerializerRowData& rRow = spContainer->GetRow(boost::numeric_cast(stSubOperationIndex), bAdded); + rRow.SetValue(_T("type"), rCurrentSubTask.first->GetSubOperationType()); + rRow.SetValue(_T("is_current"), false); + rRow.SetValue(_T("is_estimation"), rCurrentSubTask.second); + } } - // unmark the old "current" subtask - if(m_oidLastStoredIndex != -1) + // serialize current index + if (bAdded || oidCurrentIndex != m_oidLastStoredIndex) { - ISerializerRowData& rRow = spContainer->GetRow(m_oidLastStoredIndex, false); - rRow.SetValue(_T("is_current"), false); + // mark subtask at current index as "current"; don't do that if we just finished. + if (boost::numeric_cast(oidCurrentIndex) != m_vSubTasks.size()) + { + ISerializerRowData& rRow = spContainer->GetRow(oidCurrentIndex, false); + rRow.SetValue(_T("is_current"), true); + } + + // unmark the old "current" subtask + if (m_oidLastStoredIndex != -1) + { + ISerializerRowData& rRow = spContainer->GetRow(m_oidLastStoredIndex, false); + rRow.SetValue(_T("is_current"), false); + } } + + m_oidLastStoredIndex = oidCurrentIndex; } - m_oidLastStoredIndex = oidCurrentIndex; - } + m_setModifications.reset(); - m_setModifications.reset(); - - /////////////////////////////////////////////////////////////////////// - // store all the subtasks - for(size_t stSubOperationIndex = 0; stSubOperationIndex < m_vSubTasks.size(); ++stSubOperationIndex) - { - const std::pair& rCurrentSubTask = m_vSubTasks[stSubOperationIndex]; - rCurrentSubTask.first->Store(spSerializer); + /////////////////////////////////////////////////////////////////////// + // store all the subtasks + for (size_t stSubOperationIndex = 0; stSubOperationIndex < m_vSubTasks.size(); ++stSubOperationIndex) + { + const std::pair& rCurrentSubTask = m_vSubTasks[stSubOperationIndex]; + rCurrentSubTask.first->Store(spSerializer); + } } -} -void TSubTasksArray::Load(const ISerializerPtr& spSerializer) -{ - /////////////////////////////////////////////////////////////////////// + void TSubTasksArray::Load(const ISerializerPtr& spSerializer) { - ISerializerContainerPtr spContainer = spSerializer->GetContainer(_T("subtasks_info")); + /////////////////////////////////////////////////////////////////////// + { + ISerializerContainerPtr spContainer = spSerializer->GetContainer(_T("subtasks_info")); - InitSubtasksInfoColumns(spContainer); + InitSubtasksInfoColumns(spContainer); - ISerializerRowReaderPtr spRowReader = spContainer->GetRowReader(); - if(spRowReader->Next()) - spRowReader->GetValue(_T("operation"), *(int*)&m_eOperationType.Modify()); - } + ISerializerRowReaderPtr spRowReader = spContainer->GetRowReader(); + if (spRowReader->Next()) + spRowReader->GetValue(_T("operation"), *(int*)&m_eOperationType.Modify()); + } - /////////////////////////////////////////////////////////////////////// - { - m_oidLastStoredIndex = (object_id_t)-1; + /////////////////////////////////////////////////////////////////////// + { + m_oidLastStoredIndex = (object_id_t)-1; - ISerializerContainerPtr spContainer = spSerializer->GetContainer(_T("subtasks")); - ISerializerRowReaderPtr spRowReader = spContainer->GetRowReader(); + ISerializerContainerPtr spContainer = spSerializer->GetContainer(_T("subtasks")); + ISerializerRowReaderPtr spRowReader = spContainer->GetRowReader(); - InitSubtasksColumns(spContainer); + InitSubtasksColumns(spContainer); - while(spRowReader->Next()) - { - object_id_t oidID = 0; - int iType = 0; - bool bIsCurrent = false; - bool bIsEstimation = false; + while (spRowReader->Next()) + { + object_id_t oidID = 0; + int iType = 0; + bool bIsCurrent = false; + bool bIsEstimation = false; - spRowReader->GetValue(_T("id"), oidID); - spRowReader->GetValue(_T("type"), iType); - spRowReader->GetValue(_T("is_current"), bIsCurrent); - spRowReader->GetValue(_T("is_estimation"), bIsEstimation); + spRowReader->GetValue(_T("id"), oidID); + spRowReader->GetValue(_T("type"), iType); + spRowReader->GetValue(_T("is_current"), bIsCurrent); + spRowReader->GetValue(_T("is_estimation"), bIsEstimation); - if(bIsCurrent) - { - m_oidSubOperationIndex.store(oidID, std::memory_order_release); - m_oidLastStoredIndex = oidID; - } + if (bIsCurrent) + { + m_oidSubOperationIndex.store(oidID, std::memory_order_release); + m_oidLastStoredIndex = oidID; + } - // create subtask, load it and put into the array - TSubTaskBasePtr spSubTask = CreateSubtask((ESubOperationType)iType, m_rSubTaskContext); - spSubTask->Load(spSerializer); + // create subtask, load it and put into the array + TSubTaskBasePtr spSubTask = CreateSubtask((ESubOperationType)iType, m_rSubTaskContext); + spSubTask->Load(spSerializer); - if(boost::numeric_cast(oidID) != m_vSubTasks.size()) - THROW_CORE_EXCEPTION(eErr_InvalidData); + if (boost::numeric_cast(oidID) != m_vSubTasks.size()) + THROW_CORE_EXCEPTION(eErr_InvalidData); - m_vSubTasks.push_back(std::make_pair(spSubTask, bIsEstimation)); - } + m_vSubTasks.push_back(std::make_pair(spSubTask, bIsEstimation)); + } - if(m_oidLastStoredIndex == -1) - { - m_oidSubOperationIndex.store(boost::numeric_cast(m_vSubTasks.size()), std::memory_order_release); - m_oidLastStoredIndex = boost::numeric_cast(m_vSubTasks.size()); + if (m_oidLastStoredIndex == -1) + { + m_oidSubOperationIndex.store(boost::numeric_cast(m_vSubTasks.size()), std::memory_order_release); + m_oidLastStoredIndex = boost::numeric_cast(m_vSubTasks.size()); + } } + + m_setModifications.reset(); } - m_setModifications.reset(); -} - -TSubTaskBasePtr TSubTasksArray::CreateSubtask(ESubOperationType eType, TSubTaskContext& rContext) -{ - switch(eType) + TSubTaskBasePtr TSubTasksArray::CreateSubtask(ESubOperationType eType, TSubTaskContext& rContext) { - case eSubOperation_FastMove: - return boost::make_shared(boost::ref(rContext)); + switch (eType) + { + case eSubOperation_FastMove: + return boost::make_shared(boost::ref(rContext)); - case eSubOperation_Scanning: - return boost::make_shared(boost::ref(rContext)); + case eSubOperation_Scanning: + return boost::make_shared(boost::ref(rContext)); - case eSubOperation_Copying: - return boost::make_shared(boost::ref(rContext)); + case eSubOperation_Copying: + return boost::make_shared(boost::ref(rContext)); - case eSubOperation_Deleting: - return boost::make_shared(boost::ref(rContext)); + case eSubOperation_Deleting: + return boost::make_shared(boost::ref(rContext)); - default: - THROW_CORE_EXCEPTION(eErr_UnhandledCase); + default: + THROW_CORE_EXCEPTION(eErr_UnhandledCase); + } } -} -IColumnsDefinition& TSubTasksArray::InitSubtasksColumns(const ISerializerContainerPtr& spContainer) const -{ - IColumnsDefinition& rColumns = spContainer->GetColumnsDefinition(); - if(rColumns.IsEmpty()) + IColumnsDefinition& TSubTasksArray::InitSubtasksColumns(const ISerializerContainerPtr& spContainer) const { - rColumns.AddColumn(_T("id"), ColumnType::value); - rColumns.AddColumn(_T("type"), IColumnsDefinition::eType_int); - rColumns.AddColumn(_T("is_current"), IColumnsDefinition::eType_bool); - rColumns.AddColumn(_T("is_estimation"), IColumnsDefinition::eType_bool); + IColumnsDefinition& rColumns = spContainer->GetColumnsDefinition(); + if (rColumns.IsEmpty()) + { + rColumns.AddColumn(_T("id"), ColumnType::value); + rColumns.AddColumn(_T("type"), IColumnsDefinition::eType_int); + rColumns.AddColumn(_T("is_current"), IColumnsDefinition::eType_bool); + rColumns.AddColumn(_T("is_estimation"), IColumnsDefinition::eType_bool); + } + + return rColumns; } - return rColumns; -} - -IColumnsDefinition& TSubTasksArray::InitSubtasksInfoColumns(const ISerializerContainerPtr& spContainer) const -{ - IColumnsDefinition& rColumns = spContainer->GetColumnsDefinition(); - if(rColumns.IsEmpty()) + IColumnsDefinition& TSubTasksArray::InitSubtasksInfoColumns(const ISerializerContainerPtr& spContainer) const { - rColumns.AddColumn(_T("id"), ColumnType::value); - rColumns.AddColumn(_T("operation"), IColumnsDefinition::eType_int); - } + IColumnsDefinition& rColumns = spContainer->GetColumnsDefinition(); + if (rColumns.IsEmpty()) + { + rColumns.AddColumn(_T("id"), ColumnType::value); + rColumns.AddColumn(_T("operation"), IColumnsDefinition::eType_int); + } - return rColumns; + return rColumns; + } } - -END_CHCORE_NAMESPACE