From 4f302b0d1d31cdf7cbdc66207d89cd0a67219f86 Mon Sep 17 00:00:00 2001 From: malte_langkabel Date: Wed, 7 Sep 2016 14:39:34 +0200 Subject: [PATCH] logic: reimplemented task system to abort ast visiting * reimplemented interrupting TaskParseCxx by adding a listener for the MessageInterruptTask and returning a failure status code on update. This cancels the parent sequence task which results in the indexed items not getting inserted into the persistent storage * removed the capability for interrupting from TaskScheduler * changed task system to be closer to the standard behavior tree implementation * changed task system to accommodate the 3 status return types: Running, Success and Failure * made TaskGroupSequential fail once a member task fails * made TaskGroupParallel fail once a member task fails * split TaskParse... into one task for indexing and one task for injecting * added TaskRunner that handles updating and resetting the managed task * fixed numbers that are shown as parsed file count in indexing ui * fixed deadlock that originated from interaction between TaskScheduler and MessageQueue (one thread wanted to destroy a message listener on a task while the other one wanted to send as message as a task) --- src/app/data/parser/cxx/TaskParseCxx.cpp | 78 ++++---- src/app/data/parser/cxx/TaskParseWrapper.cpp | 43 ++--- src/app/data/parser/java/TaskParseJava.cpp | 61 +++---- src/lib/CMakeLists.txt | 6 + src/lib/CxxProject.cpp | 4 +- src/lib/CxxProject.h | 3 +- src/lib/JavaProject.cpp | 4 +- src/lib/JavaProject.h | 3 +- src/lib/Project.cpp | 13 +- src/lib/Project.h | 4 +- src/lib/data/IntermediateStorage.cpp | 17 ++ src/lib/data/IntermediateStorage.h | 4 +- src/lib/data/Storage.cpp | 23 +-- src/lib/data/Storage.h | 7 +- src/lib/data/TaskCleanStorage.cpp | 18 +- src/lib/data/TaskCleanStorage.h | 15 +- src/lib/data/TaskInjectStorage.cpp | 30 +++ src/lib/data/TaskInjectStorage.h | 29 +++ ...epeatWhileUnparsedSourceFilesAvailable.cpp | 47 +++++ ...kRepeatWhileUnparsedSourceFilesAvailable.h | 31 ++++ src/lib/data/parser/cxx/TaskParseCxx.h | 27 +-- src/lib/data/parser/cxx/TaskParseWrapper.h | 16 +- src/lib/data/parser/java/TaskParseJava.h | 28 +-- src/lib/utility/file/FileRegister.cpp | 14 +- src/lib/utility/messaging/MessageQueue.cpp | 30 +-- src/lib/utility/scheduling/Task.cpp | 75 ++------ src/lib/utility/scheduling/Task.h | 32 ++-- src/lib/utility/scheduling/TaskDecorator.cpp | 5 - src/lib/utility/scheduling/TaskDecorator.h | 5 +- src/lib/utility/scheduling/TaskGroup.cpp | 5 - src/lib/utility/scheduling/TaskGroup.h | 5 +- .../utility/scheduling/TaskGroupParallel.cpp | 124 +++++++------ .../utility/scheduling/TaskGroupParallel.h | 36 ++-- .../scheduling/TaskGroupSequential.cpp | 56 +++--- .../utility/scheduling/TaskGroupSequential.h | 15 +- src/lib/utility/scheduling/TaskLambda.cpp | 18 +- src/lib/utility/scheduling/TaskLambda.h | 13 +- src/lib/utility/scheduling/TaskRunner.cpp | 34 ++++ src/lib/utility/scheduling/TaskRunner.h | 24 +++ src/lib/utility/scheduling/TaskScheduler.cpp | 59 ++---- src/lib/utility/scheduling/TaskScheduler.h | 7 +- src/lib_gui/qt/window/QtIndexingDialog.cpp | 5 - src/lib_parser/data/parser/cxx/ASTVisitor.cpp | 8 +- src/lib_parser/data/parser/cxx/ASTVisitor.h | 9 +- src/test/TaskSchedulerTestSuite.h | 172 +++--------------- src/trial/data/parser/cxx/TaskParseCxx.cpp | 19 +- .../data/parser/cxx/TaskParseWrapper.cpp | 29 +-- src/trial/data/parser/java/TaskParseJava.cpp | 19 +- 48 files changed, 651 insertions(+), 678 deletions(-) create mode 100644 src/lib/data/TaskInjectStorage.cpp create mode 100644 src/lib/data/TaskInjectStorage.h create mode 100644 src/lib/data/TaskRepeatWhileUnparsedSourceFilesAvailable.cpp create mode 100644 src/lib/data/TaskRepeatWhileUnparsedSourceFilesAvailable.h create mode 100644 src/lib/utility/scheduling/TaskRunner.cpp create mode 100644 src/lib/utility/scheduling/TaskRunner.h diff --git a/src/app/data/parser/cxx/TaskParseCxx.cpp b/src/app/data/parser/cxx/TaskParseCxx.cpp index 052f4e54..2f75ef4c 100644 --- a/src/app/data/parser/cxx/TaskParseCxx.cpp +++ b/src/app/data/parser/cxx/TaskParseCxx.cpp @@ -6,7 +6,7 @@ #include "component/view/DialogView.h" #include "data/parser/cxx/CxxParser.h" -#include "data/PersistentStorage.h" +#include "data/IntermediateStorage.h" #include "utility/file/FileRegister.h" #include "utility/utility.h" @@ -29,17 +29,16 @@ std::vector TaskParseCxx::getSourceFilesFromCDB(const FilePath& compil } TaskParseCxx::TaskParseCxx( - PersistentStorage* storage, - std::shared_ptr storageMutex, + std::shared_ptr storage, std::shared_ptr fileRegister, const Parser::Arguments& arguments, DialogView* dialogView ) : m_storage(storage) - , m_storageMutex(storageMutex) , m_arguments(arguments) , m_dialogView(dialogView) , m_isCDB(false) + , m_interrupted(false) { if (arguments.compilationDatabasePath.exists()) { @@ -49,7 +48,7 @@ TaskParseCxx::TaskParseCxx( m_parser = std::make_shared(m_parserClient.get(), fileRegister); } -void TaskParseCxx::enter() +void TaskParseCxx::doEnter() { if (m_isCDB) { @@ -65,63 +64,56 @@ void TaskParseCxx::enter() } } -Task::TaskState TaskParseCxx::update() +Task::TaskState TaskParseCxx::doUpdate() { FileRegister* fileRegister = m_parser->getFileRegister(); FilePath sourcePath = fileRegister->consumeSourceFile(); - if (sourcePath.empty()) + if (!sourcePath.empty()) { - return Task::STATE_FINISHED; - } + m_dialogView->updateIndexingDialog( + fileRegister->getParsedSourceFilesCount(), fileRegister->getSourceFilesCount(), sourcePath.str() + ); - m_dialogView->updateIndexingDialog( - fileRegister->getParsedSourceFilesCount(), fileRegister->getSourceFilesCount(), sourcePath.str()); + m_storage->clear(); + m_parserClient->setStorage(m_storage); + m_parserClient->startParsingFile(); - std::shared_ptr intermediateStorage = std::make_shared(); - - m_parserClient->setStorage(intermediateStorage); - m_parserClient->startParsingFile(); - - if (m_isCDB) - { - std::vector commands = m_cdb->getCompileCommands(sourcePath.str()); - if (commands.size() > 0) + if (m_isCDB) { - m_parser->runTool(commands[0], m_arguments); + std::vector commands = m_cdb->getCompileCommands(sourcePath.str()); + if (commands.size() > 0) + { + m_parser->runTool(commands[0], m_arguments); + } + } + else + { + m_parser->runTool(std::vector(1, sourcePath.str())); + } + + m_parserClient->finishParsingFile(); + m_parserClient->resetStorage(); + + if (!m_interrupted) + { + fileRegister->markThreadFilesParsed(); } } - else - { - m_parser->runTool(std::vector(1, sourcePath.str())); - } - m_parserClient->finishParsingFile(); - m_parserClient->resetStorage(); - - { - std::lock_guard lock(*(m_storageMutex.get())); - m_storage->inject(intermediateStorage.get()); - } - - fileRegister->markThreadFilesParsed(); - - return Task::STATE_RUNNING; + return (m_interrupted ? STATE_FAILURE : STATE_SUCCESS); } -void TaskParseCxx::exit() +void TaskParseCxx::doExit() { } -void TaskParseCxx::interrupt() +void TaskParseCxx::doReset() { } -void TaskParseCxx::revert() -{ -} - -void TaskParseCxx::abort() +void TaskParseCxx::handleMessage(MessageInterruptTasks* message) { + m_interrupted = true; } diff --git a/src/app/data/parser/cxx/TaskParseWrapper.cpp b/src/app/data/parser/cxx/TaskParseWrapper.cpp index e98e762b..d6b24ed0 100644 --- a/src/app/data/parser/cxx/TaskParseWrapper.cpp +++ b/src/app/data/parser/cxx/TaskParseWrapper.cpp @@ -21,25 +21,29 @@ TaskParseWrapper::~TaskParseWrapper() { } -void TaskParseWrapper::enter() +void TaskParseWrapper::setTask(std::shared_ptr task) +{ + if (task) + { + m_taskRunner = std::make_shared(task); + } +} + +void TaskParseWrapper::doEnter() { m_dialogView->updateIndexingDialog(0, m_fileRegister->getSourceFilesCount(), ""); m_start = utility::durationStart(); m_storage->startParsing(); - - m_task->enter(); } -Task::TaskState TaskParseWrapper::update() +Task::TaskState TaskParseWrapper::doUpdate() { - return m_task->update(); + return m_taskRunner->update(); } -void TaskParseWrapper::exit() +void TaskParseWrapper::doExit() { - m_task->exit(); - m_dialogView->showProgressDialog("Finish Indexing", "Optimizing database"); m_storage->optimizeMemory(); @@ -60,26 +64,7 @@ void TaskParseWrapper::exit() ); } -void TaskParseWrapper::interrupt() +void TaskParseWrapper::doReset() { - m_task->interrupt(); -} - -void TaskParseWrapper::revert() -{ - m_task->revert(); -} - -void TaskParseWrapper::abort() -{ - m_task->abort(); - - MessageFinishedParsing().dispatch(); - - m_dialogView->finishedIndexingDialog( - m_fileRegister->getParsedSourceFilesCount(), - m_fileRegister->getSourceFilesCount(), - 0, - m_storage->getErrorCount() - ); + m_taskRunner->reset(); } diff --git a/src/app/data/parser/java/TaskParseJava.cpp b/src/app/data/parser/java/TaskParseJava.cpp index 6e09cf56..44aa9aeb 100644 --- a/src/app/data/parser/java/TaskParseJava.cpp +++ b/src/app/data/parser/java/TaskParseJava.cpp @@ -3,78 +3,67 @@ #include "component/view/DialogView.h" #include "data/parser/java/JavaParser.h" #include "data/parser/ParserClientImpl.h" -#include "data/PersistentStorage.h" +#include "data/IntermediateStorage.h" #include "utility/file/FileRegister.h" #include "utility/messaging/type/MessageFinishedParsing.h" #include "utility/text/TextAccess.h" #include "utility/utility.h" TaskParseJava::TaskParseJava( - PersistentStorage* storage, - std::shared_ptr storageMutex, + std::shared_ptr storage, std::shared_ptr fileRegister, const Parser::Arguments& arguments, DialogView* dialogView ) : m_storage(storage) - , m_storageMutex(storageMutex) , m_fileRegister(fileRegister) , m_arguments(arguments) , m_dialogView(dialogView) + , m_interrupted(false) { } -void TaskParseJava::enter() +void TaskParseJava::doEnter() { } -Task::TaskState TaskParseJava::update() +Task::TaskState TaskParseJava::doUpdate() { std::shared_ptr parserClient = std::make_shared(); std::shared_ptr parser = std::make_shared(parserClient.get()); FilePath sourcePath = m_fileRegister->consumeSourceFile(); - if (sourcePath.empty()) + if (!sourcePath.empty()) { - return Task::STATE_FINISHED; + m_dialogView->updateIndexingDialog( + m_fileRegister->getParsedSourceFilesCount(), m_fileRegister->getSourceFilesCount(), sourcePath.str() + ); + + m_storage->clear(); + parserClient->setStorage(m_storage); + parserClient->startParsingFile(); + + parser->parseFile(sourcePath, TextAccess::createFromFile(sourcePath.str()), m_arguments); + + parserClient->finishParsingFile(); + parserClient->resetStorage(); + + m_fileRegister->markThreadFilesParsed(); // todo: rename to markThreadFilesProcessed } - m_dialogView->updateIndexingDialog( - m_fileRegister->getParsedSourceFilesCount(), m_fileRegister->getSourceFilesCount(), sourcePath.str()); - - std::shared_ptr intermediateStorage = std::make_shared(); - - parserClient->setStorage(intermediateStorage); - parserClient->startParsingFile(); - - parser->parseFile(sourcePath, TextAccess::createFromFile(sourcePath.str()), m_arguments); - - parserClient->finishParsingFile(); - parserClient->resetStorage(); - - { - std::lock_guard lock(*(m_storageMutex.get())); - m_storage->inject(intermediateStorage.get()); - } - - m_fileRegister->markThreadFilesParsed(); // todo: rename to markThreadFilesProcessed - - return Task::STATE_RUNNING; + return (m_interrupted ? STATE_FAILURE : STATE_SUCCESS); } -void TaskParseJava::exit() +void TaskParseJava::doExit() { } -void TaskParseJava::interrupt() +void TaskParseJava::doReset() { } -void TaskParseJava::revert() -{ -} - -void TaskParseJava::abort() +void TaskParseJava::handleMessage(MessageInterruptTasks* message) { + m_interrupted = true; } diff --git a/src/lib/CMakeLists.txt b/src/lib/CMakeLists.txt index 245fa6e4..88535f42 100644 --- a/src/lib/CMakeLists.txt +++ b/src/lib/CMakeLists.txt @@ -192,6 +192,10 @@ add_files( data/StorageStats.h data/TaskCleanStorage.cpp data/TaskCleanStorage.h + data/TaskInjectStorage.cpp + data/TaskInjectStorage.h + data/TaskRepeatWhileUnparsedSourceFilesAvailable.cpp + data/TaskRepeatWhileUnparsedSourceFilesAvailable.h settings/ApplicationSettings.cpp settings/ApplicationSettings.h @@ -312,6 +316,8 @@ add_files( utility/scheduling/TaskGroupSequential.h utility/scheduling/TaskLambda.cpp utility/scheduling/TaskLambda.h + utility/scheduling/TaskRunner.cpp + utility/scheduling/TaskRunner.h utility/scheduling/TaskScheduler.cpp utility/scheduling/TaskScheduler.h diff --git a/src/lib/CxxProject.cpp b/src/lib/CxxProject.cpp index 2623e680..f7836c62 100644 --- a/src/lib/CxxProject.cpp +++ b/src/lib/CxxProject.cpp @@ -54,13 +54,11 @@ bool CxxProject::prepareRefresh() } std::shared_ptr CxxProject::createIndexerTask( - PersistentStorage* storage, - std::shared_ptr storageMutex, + std::shared_ptr storage, std::shared_ptr fileRegister) { return std::make_shared( storage, - storageMutex, fileRegister, getParserArguments(), getDialogView() diff --git a/src/lib/CxxProject.h b/src/lib/CxxProject.h index 7ba687c0..187674f6 100644 --- a/src/lib/CxxProject.h +++ b/src/lib/CxxProject.h @@ -26,8 +26,7 @@ private: virtual bool prepareRefresh(); virtual std::shared_ptr createIndexerTask( - PersistentStorage* storage, - std::shared_ptr storageMutex, + std::shared_ptr storage, std::shared_ptr fileRegister); virtual void updateFileManager(FileManager& fileManager); diff --git a/src/lib/JavaProject.cpp b/src/lib/JavaProject.cpp index 5e8e8a4b..39c5d41a 100644 --- a/src/lib/JavaProject.cpp +++ b/src/lib/JavaProject.cpp @@ -76,8 +76,7 @@ bool JavaProject::prepareIndexing() } std::shared_ptr JavaProject::createIndexerTask( - PersistentStorage* storage, - std::shared_ptr storageMutex, + std::shared_ptr storage, std::shared_ptr fileRegister) { Parser::Arguments arguments; @@ -100,7 +99,6 @@ std::shared_ptr JavaProject::createIndexerTask( return std::make_shared( storage, - storageMutex, fileRegister, arguments, getDialogView() diff --git a/src/lib/JavaProject.h b/src/lib/JavaProject.h index 3577d26c..6b9c813f 100644 --- a/src/lib/JavaProject.h +++ b/src/lib/JavaProject.h @@ -26,8 +26,7 @@ private: virtual bool prepareIndexing(); virtual std::shared_ptr createIndexerTask( - PersistentStorage* storage, - std::shared_ptr storageMutex, + std::shared_ptr storage, std::shared_ptr fileRegister); virtual void updateFileManager(FileManager& fileManager); diff --git a/src/lib/Project.cpp b/src/lib/Project.cpp index 55ef659b..ae92c6ba 100644 --- a/src/lib/Project.cpp +++ b/src/lib/Project.cpp @@ -6,6 +6,8 @@ #include "data/parser/java/TaskParseJava.h" #include "data/PersistentStorage.h" #include "data/TaskCleanStorage.h" +#include "data/TaskInjectStorage.h" +#include "data/TaskRepeatWhileUnparsedSourceFilesAvailable.h" #include "settings/ApplicationSettings.h" #include "settings/ProjectSettings.h" @@ -327,7 +329,16 @@ bool Project::buildIndex(bool forceRefresh) for (int i = 0; i < indexerThreadCount; i++) { - taskParallelIndexing->addTask(createIndexerTask(m_storage.get(), storageMutex, fileRegister)); + std::shared_ptr taskRepeat = std::make_shared(fileRegister); + taskParallelIndexing->addTask(taskRepeat); + + std::shared_ptr taskRepeatSequential = std::make_shared(); + taskRepeat->setTask(taskRepeatSequential); + + std::shared_ptr intermediateStorage = std::make_shared(); + + taskRepeatSequential->addTask(createIndexerTask(intermediateStorage, fileRegister)); + taskRepeatSequential->addTask(std::make_shared(intermediateStorage, m_storage)); } Task::dispatch(taskSequential); diff --git a/src/lib/Project.h b/src/lib/Project.h index 47fbb16e..e6021e09 100644 --- a/src/lib/Project.h +++ b/src/lib/Project.h @@ -12,6 +12,7 @@ class DialogView; class FileRegister; class PersistentStorage; +class IntermediateStorage; class ProjectSettings; class StorageAccessProxy; class Task; @@ -62,8 +63,7 @@ private: virtual bool prepareIndexing(); virtual bool prepareRefresh(); virtual std::shared_ptr createIndexerTask( - PersistentStorage* storage, - std::shared_ptr storageMutex, + std::shared_ptr storage, std::shared_ptr fileRegister) = 0; virtual void updateFileManager(FileManager& fileManager) = 0; diff --git a/src/lib/data/IntermediateStorage.cpp b/src/lib/data/IntermediateStorage.cpp index 76413031..1778e29b 100644 --- a/src/lib/data/IntermediateStorage.cpp +++ b/src/lib/data/IntermediateStorage.cpp @@ -12,6 +12,23 @@ IntermediateStorage::~IntermediateStorage() { } +void IntermediateStorage::clear() +{ + m_fileNamesToIds.clear(); + m_fileIdsToData.clear(); + m_nodeNamesToIds.clear(); + m_nodeIdsToData.clear(); + m_edgeNamesToIds.clear(); + m_edgeIdsToData.clear(); + m_localSymbolNamesToIds.clear(); + m_localSymbolIdsToData.clear(); + m_sourceLocations.clear(); + m_componentAccesses.clear(); + m_commentLocations.clear(); + m_errors.clear(); + m_nextId = 1; +} + Id IntermediateStorage::addFile(const std::string& name, const std::string& filePath, const std::string& modificationTime) { std::shared_ptr file = std::make_shared(0, name, filePath, modificationTime); diff --git a/src/lib/data/IntermediateStorage.h b/src/lib/data/IntermediateStorage.h index b75c1209..772a3667 100644 --- a/src/lib/data/IntermediateStorage.h +++ b/src/lib/data/IntermediateStorage.h @@ -14,6 +14,8 @@ public: IntermediateStorage(); virtual ~IntermediateStorage(); + void clear(); + virtual Id addFile(const std::string& name, const std::string& filePath, const std::string& modificationTime); virtual Id addNode(int type, const std::string& serializedName, int definitionType); virtual Id addEdge(int type, Id sourceId, Id targetId); @@ -56,8 +58,6 @@ private: std::vector m_commentLocations; std::vector m_errors; - std::unordered_map m_nodeIdsToMemberEdgeIds; - Id m_nextId; }; diff --git a/src/lib/data/Storage.cpp b/src/lib/data/Storage.cpp index 21850468..21ff310e 100644 --- a/src/lib/data/Storage.cpp +++ b/src/lib/data/Storage.cpp @@ -15,20 +15,11 @@ Storage::~Storage() { } -void Storage::startInjection() -{ - // may be implemented in derived -} - -void Storage::finishInjection() -{ - // may be implemented in derived -} - void Storage::inject(Storage* injected) { - TRACE(); + std::lock_guard lock(m_dataMutex); + TRACE(); startInjection(); std::unordered_map injectedIdToOwnId; @@ -180,3 +171,13 @@ void Storage::inject(Storage* injected) finishInjection(); } + +void Storage::startInjection() +{ + // may be implemented in derived +} + +void Storage::finishInjection() +{ + // may be implemented in derived +} diff --git a/src/lib/data/Storage.h b/src/lib/data/Storage.h index 84c48050..eb7015b5 100644 --- a/src/lib/data/Storage.h +++ b/src/lib/data/Storage.h @@ -2,6 +2,7 @@ #define STORAGE_H #include +#include #include #include "data/name/NameHierarchy.h" @@ -32,9 +33,13 @@ public: virtual void forEachCommentLocation(std::function callback) const = 0; virtual void forEachError(std::function callback) const = 0; + void inject(Storage* injected); + +private: virtual void startInjection(); virtual void finishInjection(); - void inject(Storage* injected); + + std::mutex m_dataMutex; }; #endif // STORAGE_H diff --git a/src/lib/data/TaskCleanStorage.cpp b/src/lib/data/TaskCleanStorage.cpp index ce0c5289..694047cd 100644 --- a/src/lib/data/TaskCleanStorage.cpp +++ b/src/lib/data/TaskCleanStorage.cpp @@ -12,33 +12,25 @@ TaskCleanStorage::TaskCleanStorage( { } -void TaskCleanStorage::enter() +void TaskCleanStorage::doEnter() { m_dialogView->showProgressDialog("Clearing Files", std::to_string(m_filePaths.size()) + " Files"); } -Task::TaskState TaskCleanStorage::update() +Task::TaskState TaskCleanStorage::doUpdate() { m_storage->clearFileElements(m_filePaths); m_filePaths.clear(); - return Task::STATE_FINISHED; + return STATE_SUCCESS; } -void TaskCleanStorage::exit() +void TaskCleanStorage::doExit() { m_dialogView->hideProgressDialog(); } -void TaskCleanStorage::interrupt() -{ -} - -void TaskCleanStorage::revert() -{ -} - -void TaskCleanStorage::abort() +void TaskCleanStorage::doReset() { } diff --git a/src/lib/data/TaskCleanStorage.h b/src/lib/data/TaskCleanStorage.h index 712f713d..9fbd23be 100644 --- a/src/lib/data/TaskCleanStorage.h +++ b/src/lib/data/TaskCleanStorage.h @@ -19,18 +19,15 @@ public: DialogView* dialogView ); - virtual void enter(); - virtual TaskState update(); - virtual void exit(); - - virtual void interrupt(); - virtual void revert(); - virtual void abort(); - private: + virtual void doEnter(); + virtual TaskState doUpdate(); + virtual void doExit(); + virtual void doReset(); + PersistentStorage* m_storage; std::vector m_filePaths; DialogView* m_dialogView; }; -#endif // TASK_PARSE_CXX_H +#endif // TASK_CLEAN_STORAGE_H diff --git a/src/lib/data/TaskInjectStorage.cpp b/src/lib/data/TaskInjectStorage.cpp new file mode 100644 index 00000000..7f099378 --- /dev/null +++ b/src/lib/data/TaskInjectStorage.cpp @@ -0,0 +1,30 @@ +#include "data/TaskInjectStorage.h" + +#include "data/Storage.h" + +TaskInjectStorage::TaskInjectStorage( + std::shared_ptr source, + std::shared_ptr target +) + : m_source(source) + , m_target(target) +{ +} + +void TaskInjectStorage::doEnter() +{ +} + +Task::TaskState TaskInjectStorage::doUpdate() +{ + m_target->inject(m_source.get()); + return STATE_SUCCESS; +} + +void TaskInjectStorage::doExit() +{ +} + +void TaskInjectStorage::doReset() +{ +} diff --git a/src/lib/data/TaskInjectStorage.h b/src/lib/data/TaskInjectStorage.h new file mode 100644 index 00000000..9c9a28d8 --- /dev/null +++ b/src/lib/data/TaskInjectStorage.h @@ -0,0 +1,29 @@ +#ifndef TASK_INJECT_STORAGE_H +#define TASK_INJECT_STORAGE_H + +#include + +#include "utility/scheduling/Task.h" + +class Storage; + +class TaskInjectStorage + : public Task +{ +public: + TaskInjectStorage( + std::shared_ptr source, + std::shared_ptr target + ); + +private: + virtual void doEnter(); + virtual TaskState doUpdate(); + virtual void doExit(); + virtual void doReset(); + + std::shared_ptr m_source; + std::shared_ptr m_target; +}; + +#endif // TASK_INJECT_STORAGE_H diff --git a/src/lib/data/TaskRepeatWhileUnparsedSourceFilesAvailable.cpp b/src/lib/data/TaskRepeatWhileUnparsedSourceFilesAvailable.cpp new file mode 100644 index 00000000..49129346 --- /dev/null +++ b/src/lib/data/TaskRepeatWhileUnparsedSourceFilesAvailable.cpp @@ -0,0 +1,47 @@ +#include "data/TaskRepeatWhileUnparsedSourceFilesAvailable.h" + +#include "utility/file/FileRegister.h" + +TaskRepeatWhileUnparsedSourceFilesAvailable::TaskRepeatWhileUnparsedSourceFilesAvailable( + std::shared_ptr fileRegister +) + : m_fileRegister(fileRegister) +{ +} + +void TaskRepeatWhileUnparsedSourceFilesAvailable::setTask(std::shared_ptr task) +{ + if (task) + { + m_taskRunner = std::make_shared(task); + } +} + +void TaskRepeatWhileUnparsedSourceFilesAvailable::doEnter() +{ +} + +Task::TaskState TaskRepeatWhileUnparsedSourceFilesAvailable::doUpdate() +{ + TaskState state = m_taskRunner->update(); + + if (state == Task::STATE_SUCCESS) + { + if(m_fileRegister->getUnparsedSourceFilePaths().size() != 0) + { + state = Task::STATE_RUNNING; + m_taskRunner->reset(); + } + } + + return state; +} + +void TaskRepeatWhileUnparsedSourceFilesAvailable::doExit() +{ +} + +void TaskRepeatWhileUnparsedSourceFilesAvailable::doReset() +{ + m_taskRunner->reset(); +} diff --git a/src/lib/data/TaskRepeatWhileUnparsedSourceFilesAvailable.h b/src/lib/data/TaskRepeatWhileUnparsedSourceFilesAvailable.h new file mode 100644 index 00000000..986ba607 --- /dev/null +++ b/src/lib/data/TaskRepeatWhileUnparsedSourceFilesAvailable.h @@ -0,0 +1,31 @@ +#ifndef TASK_REPEAT_WHILE_UNPARSED_SOURCE_FILES_AVAILABLE_H +#define TASK_REPEAT_WHILE_UNPARSED_SOURCE_FILES_AVAILABLE_H + +#include + +#include "utility/scheduling/TaskDecorator.h" +#include "utility/scheduling/TaskRunner.h" + +class FileRegister; + +class TaskRepeatWhileUnparsedSourceFilesAvailable + : public TaskDecorator +{ +public: + TaskRepeatWhileUnparsedSourceFilesAvailable( + std::shared_ptr fileRegister + ); + + virtual void setTask(std::shared_ptr task); + +private: + virtual void doEnter(); + virtual TaskState doUpdate(); + virtual void doExit(); + virtual void doReset(); + + std::shared_ptr m_fileRegister; + std::shared_ptr m_taskRunner; +}; + +#endif // TASK_REPEAT_WHILE_UNPARSED_SOURCE_FILES_AVAILABLE_H diff --git a/src/lib/data/parser/cxx/TaskParseCxx.h b/src/lib/data/parser/cxx/TaskParseCxx.h index 72596082..265526cb 100644 --- a/src/lib/data/parser/cxx/TaskParseCxx.h +++ b/src/lib/data/parser/cxx/TaskParseCxx.h @@ -9,11 +9,13 @@ #include "data/parser/ParserClientImpl.h" #include "utility/scheduling/Task.h" #include "utility/TimePoint.h" +#include "utility/messaging/type/MessageInterruptTasks.h" +#include "utility/messaging/MessageListener.h" class CxxParser; class DialogView; class FileRegister; -class PersistentStorage; +class IntermediateStorage; namespace clang { @@ -25,28 +27,27 @@ namespace clang class TaskParseCxx : public Task + , public MessageListener { public: static std::vector getSourceFilesFromCDB(const FilePath& compilationDatabasePath); TaskParseCxx( - PersistentStorage* storage, - std::shared_ptr storageMutex, + std::shared_ptr storage, std::shared_ptr fileRegister, const Parser::Arguments& arguments, DialogView* dialogView ); - virtual void enter(); - virtual TaskState update(); - virtual void exit(); - - virtual void interrupt(); - virtual void revert(); - virtual void abort(); - private: - PersistentStorage* m_storage; + virtual void doEnter(); + virtual TaskState doUpdate(); + virtual void doExit(); + virtual void doReset(); + + virtual void handleMessage(MessageInterruptTasks* message); + + std::shared_ptr m_storage; std::shared_ptr m_storageMutex; const Parser::Arguments m_arguments; @@ -57,6 +58,8 @@ private: bool m_isCDB; std::shared_ptr m_cdb; + + bool m_interrupted; }; #endif // TASK_PARSE_CXX_H diff --git a/src/lib/data/parser/cxx/TaskParseWrapper.h b/src/lib/data/parser/cxx/TaskParseWrapper.h index 17564b5a..41e9b0a5 100644 --- a/src/lib/data/parser/cxx/TaskParseWrapper.h +++ b/src/lib/data/parser/cxx/TaskParseWrapper.h @@ -5,6 +5,8 @@ #include "data/parser/Parser.h" #include "data/parser/ParserClientImpl.h" +#include "utility/scheduling/Task.h" +#include "utility/scheduling/TaskRunner.h" #include "utility/scheduling/TaskDecorator.h" #include "utility/TimePoint.h" @@ -23,20 +25,20 @@ public: ); virtual ~TaskParseWrapper(); - virtual void enter(); - virtual TaskState update(); - virtual void exit(); - - virtual void interrupt(); - virtual void revert(); - virtual void abort(); + virtual void setTask(std::shared_ptr task); private: + virtual void doEnter(); + virtual TaskState doUpdate(); + virtual void doExit(); + virtual void doReset(); + PersistentStorage* m_storage; std::shared_ptr m_fileRegister; DialogView* m_dialogView; TimePoint m_start; + std::shared_ptr m_taskRunner; }; #endif // TASK_PARSE_WRAPPER_H diff --git a/src/lib/data/parser/java/TaskParseJava.h b/src/lib/data/parser/java/TaskParseJava.h index 6bc99655..8428e5f5 100644 --- a/src/lib/data/parser/java/TaskParseJava.h +++ b/src/lib/data/parser/java/TaskParseJava.h @@ -5,37 +5,39 @@ #include "data/parser/Parser.h" #include "utility/scheduling/Task.h" +#include "utility/messaging/type/MessageInterruptTasks.h" +#include "utility/messaging/MessageListener.h" class DialogView; class FileRegister; -class PersistentStorage; +class IntermediateStorage; class TaskParseJava : public Task + , public MessageListener { public: TaskParseJava( - PersistentStorage* storage, - std::shared_ptr storageMutex, + std::shared_ptr storage, std::shared_ptr fileRegister, const Parser::Arguments& arguments, DialogView* dialogView ); - virtual void enter(); - virtual TaskState update(); - virtual void exit(); - - virtual void interrupt(); - virtual void revert(); - virtual void abort(); - private: - PersistentStorage* m_storage; - std::shared_ptr m_storageMutex; + virtual void doEnter(); + virtual TaskState doUpdate(); + virtual void doExit(); + virtual void doReset(); + + virtual void handleMessage(MessageInterruptTasks* message); + + std::shared_ptr m_storage; std::shared_ptr m_fileRegister; Parser::Arguments m_arguments; DialogView* m_dialogView; + + bool m_interrupted; }; #endif // TASK_PARSE_JAVA_H diff --git a/src/lib/utility/file/FileRegister.cpp b/src/lib/utility/file/FileRegister.cpp index cb2dafa2..d871cf13 100644 --- a/src/lib/utility/file/FileRegister.cpp +++ b/src/lib/utility/file/FileRegister.cpp @@ -230,5 +230,17 @@ size_t FileRegister::getSourceFilesCount() const size_t FileRegister::getParsedSourceFilesCount() const { - return getSourceFilesCount() - getUnparsedSourceFilePaths().size(); + std::lock_guard lock(m_sourceFileMutex); + + size_t count = 0; + + for (std::pair&& p : m_sourceFilePaths) + { + if (p.second == STATE_PARSED) + { + count++; + } + } + + return count; } diff --git a/src/lib/utility/messaging/MessageQueue.cpp b/src/lib/utility/messaging/MessageQueue.cpp index a6683b47..fe269edf 100644 --- a/src/lib/utility/messaging/MessageQueue.cpp +++ b/src/lib/utility/messaging/MessageQueue.cpp @@ -260,24 +260,26 @@ void MessageQueue::sendMessageAsTask(std::shared_ptr message, bool { std::shared_ptr taskGroup = std::make_shared(); - std::lock_guard lock(m_listenersMutex); - for (size_t i = 0; i < m_listeners.size(); i++) { - MessageListenerBase* listener = m_listeners[i]; - - if (listener->getType() == message->getType()) + std::lock_guard lock(m_listenersMutex); + for (size_t i = 0; i < m_listeners.size(); i++) { - uint listenerId = listener->getId(); - taskGroup->addTask(std::make_shared( - [listenerId, message]() - { - MessageListenerBase* listener = MessageQueue::getInstance()->getListenerById(listenerId); - if (listener) + MessageListenerBase* listener = m_listeners[i]; + + if (listener->getType() == message->getType()) + { + uint listenerId = listener->getId(); + taskGroup->addTask(std::make_shared( + [listenerId, message]() { - listener->handleMessageBase(message.get()); + MessageListenerBase* listener = MessageQueue::getInstance()->getListenerById(listenerId); + if (listener) + { + listener->handleMessageBase(message.get()); + } } - } - )); + )); + } } } diff --git a/src/lib/utility/scheduling/Task.cpp b/src/lib/utility/scheduling/Task.cpp index 762ad091..6c462e2f 100644 --- a/src/lib/utility/scheduling/Task.cpp +++ b/src/lib/utility/scheduling/Task.cpp @@ -14,7 +14,8 @@ void Task::dispatchNext(std::shared_ptr task) } Task::Task() - : m_state(STATE_NEW) + : m_enterCalled(false) + , m_exitCalled(false) { } @@ -22,74 +23,28 @@ Task::~Task() { } -Task::TaskState Task::getState() const +Task::TaskState Task::update() { - return m_state; -} - -Task::TaskState Task::processTask() -{ - switch (m_state) + if (!m_enterCalled) { - case STATE_NEW: - case STATE_CANCELED: - enter(); - case STATE_RUNNING: - { - TaskState newState = update(); - if (newState == STATE_NEW || newState == STATE_CANCELED) - { - LOG_ERROR("Task can't change to state NEW or CANCELLED"); - return m_state; - } - - setState(newState); - if (m_state == STATE_FINISHED) - { - exit(); - } - } - break; - case STATE_FINISHED: - break; + doEnter(); + m_enterCalled = true; } - return m_state; -} + TaskState state = doUpdate(); -Task::TaskState Task::interruptTask() -{ - switch (m_state) + if (state != STATE_RUNNING && !m_exitCalled) { - case STATE_NEW: - abort(); - break; - case STATE_CANCELED: - break; - case STATE_RUNNING: - interrupt(); - exit(); - break; - case STATE_FINISHED: - revert(); - break; + doExit(); + m_exitCalled = true; } - setState(STATE_CANCELED); - return m_state; + return state; } -void Task::executeTask() +void Task::reset() { - TaskState state; - do - { - state = processTask(); - } - while (state != STATE_FINISHED); -} - -void Task::setState(TaskState state) -{ - m_state = state; + doReset(); + m_enterCalled = false; + m_exitCalled = false; } diff --git a/src/lib/utility/scheduling/Task.h b/src/lib/utility/scheduling/Task.h index 23d62ac7..def6a82e 100644 --- a/src/lib/utility/scheduling/Task.h +++ b/src/lib/utility/scheduling/Task.h @@ -8,10 +8,9 @@ class Task public: enum TaskState { - STATE_NEW, STATE_RUNNING, - STATE_FINISHED, - STATE_CANCELED + STATE_SUCCESS, + STATE_FAILURE }; static void dispatch(std::shared_ptr task); @@ -20,26 +19,19 @@ public: Task(); virtual ~Task(); - TaskState getState() const; +// virtual TaskState getState() const = 0; - TaskState processTask(); - TaskState interruptTask(); - - void executeTask(); - - virtual void enter() = 0; - virtual TaskState update() = 0; - virtual void exit() = 0; - - virtual void interrupt() = 0; - virtual void revert() = 0; - virtual void abort() = 0; - -protected: - void setState(TaskState state); + TaskState update(); + void reset(); private: - TaskState m_state; + virtual void doEnter() = 0; + virtual Task::TaskState doUpdate() = 0; + virtual void doExit() = 0; + virtual void doReset() = 0; + + bool m_enterCalled; + bool m_exitCalled; }; #endif // TASK_H diff --git a/src/lib/utility/scheduling/TaskDecorator.cpp b/src/lib/utility/scheduling/TaskDecorator.cpp index f89872c4..a106ec6c 100644 --- a/src/lib/utility/scheduling/TaskDecorator.cpp +++ b/src/lib/utility/scheduling/TaskDecorator.cpp @@ -7,8 +7,3 @@ TaskDecorator::TaskDecorator() TaskDecorator::~TaskDecorator() { } - -void TaskDecorator::setTask(std::shared_ptr task) -{ - m_task = task; -} diff --git a/src/lib/utility/scheduling/TaskDecorator.h b/src/lib/utility/scheduling/TaskDecorator.h index 34e24288..e50a95ee 100644 --- a/src/lib/utility/scheduling/TaskDecorator.h +++ b/src/lib/utility/scheduling/TaskDecorator.h @@ -12,10 +12,7 @@ public: TaskDecorator(); virtual ~TaskDecorator(); - void setTask(std::shared_ptr task); - -protected: - std::shared_ptr m_task; + virtual void setTask(std::shared_ptr task) = 0; }; #endif // TASK_DECORATOR_H diff --git a/src/lib/utility/scheduling/TaskGroup.cpp b/src/lib/utility/scheduling/TaskGroup.cpp index 54d1db5c..7a70c5a6 100644 --- a/src/lib/utility/scheduling/TaskGroup.cpp +++ b/src/lib/utility/scheduling/TaskGroup.cpp @@ -7,8 +7,3 @@ TaskGroup::TaskGroup() TaskGroup::~TaskGroup() { } - -void TaskGroup::addTask(std::shared_ptr task) -{ - m_tasks.push_back(task); -} diff --git a/src/lib/utility/scheduling/TaskGroup.h b/src/lib/utility/scheduling/TaskGroup.h index cd355f94..9dd4c712 100644 --- a/src/lib/utility/scheduling/TaskGroup.h +++ b/src/lib/utility/scheduling/TaskGroup.h @@ -13,10 +13,7 @@ public: TaskGroup(); virtual ~TaskGroup(); - void addTask(std::shared_ptr task); - -protected: - std::vector> m_tasks; + virtual void addTask(std::shared_ptr task) = 0; }; #endif // TASK_GROUP_H diff --git a/src/lib/utility/scheduling/TaskGroupParallel.cpp b/src/lib/utility/scheduling/TaskGroupParallel.cpp index 8fce2e81..bfd8d7da 100644 --- a/src/lib/utility/scheduling/TaskGroupParallel.cpp +++ b/src/lib/utility/scheduling/TaskGroupParallel.cpp @@ -1,6 +1,9 @@ #include "utility/scheduling/TaskGroupParallel.h" +#include "utility/ScopedFunctor.h" + TaskGroupParallel::TaskGroupParallel() + : m_needsToStartThreads(true) { } @@ -8,83 +11,88 @@ TaskGroupParallel::~TaskGroupParallel() { } -void TaskGroupParallel::enter() +void TaskGroupParallel::addTask(std::shared_ptr task) { - m_interrupt = false; - m_running = false; - m_activeTaskCount = 0; + m_tasks.push_back(std::make_shared(std::make_shared(task))); } -Task::TaskState TaskGroupParallel::update() +void TaskGroupParallel::doEnter() { - if (!m_running) + m_taskFailed = false; + + if (m_needsToStartThreads) { + m_needsToStartThreads = false; + m_activeTaskCount = 0; for (size_t i = 0; i < m_tasks.size(); i++) { - m_threads.push_back(std::thread(&TaskGroupParallel::processTaskThreaded, this, m_tasks[i])); - - std::lock_guard lock(m_activeTaskCountMutex); + m_tasks[i]->thread = std::make_shared(&TaskGroupParallel::processTaskThreaded, this, m_tasks[i]); + m_tasks[i]->active = true; m_activeTaskCount++; } - m_running = true; + } +} + +Task::TaskState TaskGroupParallel::doUpdate() +{ + if (m_tasks.size() != 0 && getActveTaskCount() > 0) + { + return STATE_RUNNING; } - int activeTaskCount = 0; + return (m_taskFailed ? STATE_FAILURE : STATE_SUCCESS); +} + +void TaskGroupParallel::doExit() +{ + for (size_t i = 0; i < m_tasks.size(); i++) { - std::lock_guard lock(m_activeTaskCountMutex); - activeTaskCount = m_activeTaskCount; + m_tasks[i]->thread->join(); + m_tasks[i]->thread.reset(); } +} - if (activeTaskCount == 0) +void TaskGroupParallel::doReset() +{ + for (size_t i = 0; i < m_tasks.size(); i++) { - return (m_interrupt ? STATE_CANCELED : STATE_FINISHED); - } - - return Task::STATE_RUNNING; -} - -void TaskGroupParallel::exit() -{ - for (size_t i = 0; i < m_threads.size(); i++) - { - m_threads[i].join(); - } - m_threads.clear(); -} - -void TaskGroupParallel::interrupt() -{ - m_interrupt = true; -} - -void TaskGroupParallel::revert() -{ - m_interrupt = true; -} - -void TaskGroupParallel::abort() -{ - m_interrupt = true; -} - - -void TaskGroupParallel::processTaskThreaded(std::shared_ptr task) -{ - Task::TaskState state = Task::STATE_NEW; - while (state != Task::STATE_FINISHED && state != Task::STATE_CANCELED) - { - if (m_interrupt) + m_tasks[i]->taskRunner->reset(); + if (!m_tasks[i]->active) { - state = task->interruptTask(); - } - else - { - state = task->processTask(); + m_tasks[i]->thread->join(); + m_tasks[i]->thread = std::make_shared(&TaskGroupParallel::processTaskThreaded, this, m_tasks[i]); + m_tasks[i]->active = true; + m_activeTaskCount++; } } +} - { +void TaskGroupParallel::processTaskThreaded(std::shared_ptr taskInfo) +{ + ScopedFunctor functor([&](){ std::lock_guard lock(m_activeTaskCountMutex); - m_activeTaskCount--; // not safe! if exception hits this thread before this point the count is not decremented. + m_activeTaskCount--; + }); + + + while (true) + { + TaskState state = taskInfo->taskRunner->update(); + + if (state != STATE_RUNNING) + { + if (state == STATE_FAILURE) + { + m_taskFailed = true; + } + taskInfo->active = false; + break; + } } } + +int TaskGroupParallel::getActveTaskCount() const +{ + std::lock_guard lock(m_activeTaskCountMutex); + return m_activeTaskCount; +} diff --git a/src/lib/utility/scheduling/TaskGroupParallel.h b/src/lib/utility/scheduling/TaskGroupParallel.h index 371af8e8..9f646d31 100644 --- a/src/lib/utility/scheduling/TaskGroupParallel.h +++ b/src/lib/utility/scheduling/TaskGroupParallel.h @@ -1,10 +1,12 @@ #ifndef TASK_GROUP_PARALLEL_H #define TASK_GROUP_PARALLEL_H +#include #include #include #include "utility/scheduling/TaskGroup.h" +#include "utility/scheduling/TaskRunner.h" class TaskGroupParallel : public TaskGroup @@ -13,24 +15,34 @@ public: TaskGroupParallel(); virtual ~TaskGroupParallel(); - virtual void enter(); - virtual TaskState update(); - virtual void exit(); - - virtual void interrupt(); - virtual void revert(); - virtual void abort(); + virtual void addTask(std::shared_ptr task); private: - void processTaskThreaded(std::shared_ptr task); + struct TaskInfo + { + TaskInfo(std::shared_ptr taskRunner) + : taskRunner(taskRunner) + , active(false) + {} + std::shared_ptr taskRunner; + std::shared_ptr thread; + volatile bool active; + }; - volatile bool m_interrupt; - bool m_running; + virtual void doEnter(); + virtual TaskState doUpdate(); + virtual void doExit(); + virtual void doReset(); - std::vector m_threads; + void processTaskThreaded(std::shared_ptr taskInfo); + int getActveTaskCount() const; + std::vector> m_tasks; + bool m_needsToStartThreads; + + volatile bool m_taskFailed; volatile int m_activeTaskCount; - std::mutex m_activeTaskCountMutex; + mutable std::mutex m_activeTaskCountMutex; }; #endif // TASK_GROUP_PARALLEL_H diff --git a/src/lib/utility/scheduling/TaskGroupSequential.cpp b/src/lib/utility/scheduling/TaskGroupSequential.cpp index 67c140c6..ffad6553 100644 --- a/src/lib/utility/scheduling/TaskGroupSequential.cpp +++ b/src/lib/utility/scheduling/TaskGroupSequential.cpp @@ -1,7 +1,7 @@ #include "utility/scheduling/TaskGroupSequential.h" +#include TaskGroupSequential::TaskGroupSequential() - : m_taskIndex(-1) { } @@ -9,55 +9,49 @@ TaskGroupSequential::~TaskGroupSequential() { } -void TaskGroupSequential::enter() +void TaskGroupSequential::addTask(std::shared_ptr task) { + m_taskRunners.push_back(std::make_shared(task)); } -Task::TaskState TaskGroupSequential::update() +void TaskGroupSequential::doEnter() { - if (!m_tasks.size()) + m_taskIndex = 0; +} + +Task::TaskState TaskGroupSequential::doUpdate() +{ + if (m_taskIndex >= int(m_taskRunners.size())) { - return Task::STATE_FINISHED; + return STATE_SUCCESS; + } + else if (m_taskIndex < 0) + { + return STATE_FAILURE; } - if (m_taskIndex < 0 || m_tasks[m_taskIndex]->getState() != Task::STATE_RUNNING) + TaskState state = m_taskRunners[m_taskIndex]->update(); + + if (state == STATE_SUCCESS) { m_taskIndex++; } - - std::shared_ptr task = m_tasks[m_taskIndex]; - - TaskState state = task->processTask(); - - if (state == Task::STATE_FINISHED && size_t(m_taskIndex + 1) == m_tasks.size()) + else if (state == STATE_FAILURE) { - return Task::STATE_FINISHED; + m_taskIndex = -1; } - return Task::STATE_RUNNING; + return STATE_RUNNING; } -void TaskGroupSequential::exit() +void TaskGroupSequential::doExit() { } -void TaskGroupSequential::interrupt() +void TaskGroupSequential::doReset() { - for (size_t i = 0; i < m_tasks.size(); i++) + for (size_t i = 0; i < m_taskRunners.size(); i++) { - m_tasks[i]->interruptTask(); + m_taskRunners[i]->reset(); } } - -void TaskGroupSequential::revert() -{ - for (int i = m_tasks.size() - 1; i >= 0; i--) - { - m_tasks[i]->interruptTask(); - } -} - -void TaskGroupSequential::abort() -{ - interrupt(); -} diff --git a/src/lib/utility/scheduling/TaskGroupSequential.h b/src/lib/utility/scheduling/TaskGroupSequential.h index 43d05fd1..40845eeb 100644 --- a/src/lib/utility/scheduling/TaskGroupSequential.h +++ b/src/lib/utility/scheduling/TaskGroupSequential.h @@ -2,6 +2,7 @@ #define TASK_GROUP_SEQUENTIAL_H #include "utility/scheduling/TaskGroup.h" +#include "utility/scheduling/TaskRunner.h" class TaskGroupSequential : public TaskGroup @@ -10,15 +11,15 @@ public: TaskGroupSequential(); virtual ~TaskGroupSequential(); - virtual void enter(); - virtual TaskState update(); - virtual void exit(); - - virtual void interrupt(); - virtual void revert(); - virtual void abort(); + virtual void addTask(std::shared_ptr task); private: + virtual void doEnter(); + virtual TaskState doUpdate(); + virtual void doExit(); + virtual void doReset(); + + std::vector> m_taskRunners; int m_taskIndex; }; diff --git a/src/lib/utility/scheduling/TaskLambda.cpp b/src/lib/utility/scheduling/TaskLambda.cpp index 7639bb1a..c48cea8c 100644 --- a/src/lib/utility/scheduling/TaskLambda.cpp +++ b/src/lib/utility/scheduling/TaskLambda.cpp @@ -9,28 +9,20 @@ TaskLambda::~TaskLambda() { } -void TaskLambda::enter() +void TaskLambda::doEnter() { } -Task::TaskState TaskLambda::update() +Task::TaskState TaskLambda::doUpdate() { m_func(); - return Task::STATE_FINISHED; + return STATE_SUCCESS; } -void TaskLambda::exit() +void TaskLambda::doExit() { } -void TaskLambda::interrupt() -{ -} - -void TaskLambda::revert() -{ -} - -void TaskLambda::abort() +void TaskLambda::doReset() { } diff --git a/src/lib/utility/scheduling/TaskLambda.h b/src/lib/utility/scheduling/TaskLambda.h index f77fe64c..0a98f2a0 100644 --- a/src/lib/utility/scheduling/TaskLambda.h +++ b/src/lib/utility/scheduling/TaskLambda.h @@ -12,15 +12,12 @@ public: TaskLambda(std::function func); virtual ~TaskLambda(); - virtual void enter(); - virtual TaskState update(); - virtual void exit(); - - virtual void interrupt(); - virtual void revert(); - virtual void abort(); - private: + virtual void doEnter(); + virtual TaskState doUpdate(); + virtual void doExit(); + virtual void doReset(); + std::function m_func; }; diff --git a/src/lib/utility/scheduling/TaskRunner.cpp b/src/lib/utility/scheduling/TaskRunner.cpp new file mode 100644 index 00000000..48836d32 --- /dev/null +++ b/src/lib/utility/scheduling/TaskRunner.cpp @@ -0,0 +1,34 @@ +#include "utility/scheduling/TaskRunner.h" + +TaskRunner::TaskRunner(std::shared_ptr task) + : m_task(task) + , m_reset(false) +{ +} + +TaskRunner::~TaskRunner() +{ +} + +//Task::TaskState TaskRunner::getState() const +//{ +// return m_task->getState(); +//} + +Task::TaskState TaskRunner::update() +{ + if (m_reset) + { + m_task->reset(); + m_reset = false; + } + + return m_task->update(); +} + +void TaskRunner::reset() +{ + m_reset = true; +} + + diff --git a/src/lib/utility/scheduling/TaskRunner.h b/src/lib/utility/scheduling/TaskRunner.h new file mode 100644 index 00000000..052afa33 --- /dev/null +++ b/src/lib/utility/scheduling/TaskRunner.h @@ -0,0 +1,24 @@ +#ifndef TASK_RUNNER_H +#define TASK_RUNNER_H + +#include + +#include "utility/scheduling/Task.h" + +class TaskRunner +{ +public: + TaskRunner(std::shared_ptr task); + ~TaskRunner(); + + //Task::TaskState getState() const; + + Task::TaskState update(); + void reset(); + +private: + std::shared_ptr m_task; + bool m_reset; +}; + +#endif // TASK_H diff --git a/src/lib/utility/scheduling/TaskScheduler.cpp b/src/lib/utility/scheduling/TaskScheduler.cpp index fd562016..8f1d7925 100644 --- a/src/lib/utility/scheduling/TaskScheduler.cpp +++ b/src/lib/utility/scheduling/TaskScheduler.cpp @@ -19,29 +19,23 @@ std::shared_ptr TaskScheduler::getInstance() void TaskScheduler::pushTask(std::shared_ptr task) { std::lock_guard lock(m_tasksMutex); - m_tasks.push_back(task); + m_taskRunners.push_back(std::make_shared(task)); } void TaskScheduler::pushNextTask(std::shared_ptr task) { std::lock_guard lock(m_tasksMutex); - if (m_tasks.size() == 0) + if (m_taskRunners.size() == 0) { - m_tasks.push_front(task); + m_taskRunners.push_front(std::make_shared(task)); } else { - m_tasks.insert(m_tasks.begin() + 1, task); + m_taskRunners.insert(m_taskRunners.begin() + 1, std::make_shared(task)); } } -void TaskScheduler::interruptCurrentTask() -{ - std::lock_guard lock(m_tasksMutex); - m_interruptTask = true; -} - void TaskScheduler::startSchedulerLoopThreaded() { std::thread(&TaskScheduler::startSchedulerLoop, this).detach(); @@ -57,7 +51,7 @@ void TaskScheduler::startSchedulerLoop() if (m_loopIsRunning) { - LOG_ERROR("Loop is already running"); + LOG_ERROR("Unable to start task scheduler. Loop is already running."); return; } @@ -97,14 +91,12 @@ void TaskScheduler::stopSchedulerLoop() if (!m_loopIsRunning) { - LOG_WARNING("Loop is not running"); + LOG_WARNING("Unable to stop task scheduler. Loop is not running."); } m_loopIsRunning = false; } - interruptCurrentTask(); - while (true) { { @@ -129,7 +121,7 @@ bool TaskScheduler::loopIsRunning() const bool TaskScheduler::hasTasksQueued() const { std::lock_guard lock(m_tasksMutex); - return m_tasks.size(); + return m_taskRunners.size(); } std::shared_ptr TaskScheduler::s_instance; @@ -137,7 +129,6 @@ std::shared_ptr TaskScheduler::s_instance; TaskScheduler::TaskScheduler() : m_loopIsRunning(false) , m_threadIsRunning(false) - , m_interruptTask(false) { } @@ -145,41 +136,19 @@ void TaskScheduler::processTasks() { std::lock_guard lock(m_tasksMutex); - while (m_tasks.size()) + while (m_taskRunners.size()) { - bool interrupt = m_interruptTask; - m_interruptTask = false; - - std::shared_ptr task = m_tasks.front(); - Task::TaskState state; + std::shared_ptr runner = m_taskRunners.front(); m_tasksMutex.unlock(); - if (interrupt) - { - state = task->interruptTask(); - } - else - { - state = task->processTask(); - } + + Task::TaskState state = runner->update(); + m_tasksMutex.lock(); - if (state == Task::STATE_FINISHED || state == Task::STATE_CANCELED) + if (state != Task::STATE_RUNNING) { - m_tasks.pop_front(); + m_taskRunners.pop_front(); } } - - m_interruptTask = false; -} - -void TaskScheduler::handleMessage(MessageInterruptTasks* message) -{ - interruptCurrentTask(); - - std::lock_guard lock(m_tasksMutex); - if (m_tasks.size()) - { - MessageStatus("Stop running tasks...", false, true).dispatch(); - } } diff --git a/src/lib/utility/scheduling/TaskScheduler.h b/src/lib/utility/scheduling/TaskScheduler.h index de7197e5..8b96550d 100644 --- a/src/lib/utility/scheduling/TaskScheduler.h +++ b/src/lib/utility/scheduling/TaskScheduler.h @@ -8,16 +8,15 @@ #include "utility/messaging/MessageListener.h" #include "utility/messaging/type/MessageInterruptTasks.h" #include "utility/scheduling/Task.h" +#include "utility/scheduling/TaskRunner.h" class TaskScheduler - : public MessageListener { public: static std::shared_ptr getInstance(); void pushTask(std::shared_ptr task); void pushNextTask(std::shared_ptr task); - void interruptCurrentTask(); void startSchedulerLoopThreaded(); void startSchedulerLoop(); @@ -35,13 +34,11 @@ private: void processTasks(); - virtual void handleMessage(MessageInterruptTasks* message); bool m_loopIsRunning; bool m_threadIsRunning; - std::deque> m_tasks; - bool m_interruptTask; + std::deque> m_taskRunners; mutable std::mutex m_tasksMutex; mutable std::mutex m_loopMutex; diff --git a/src/lib_gui/qt/window/QtIndexingDialog.cpp b/src/lib_gui/qt/window/QtIndexingDialog.cpp index 910d550d..3be10c2a 100644 --- a/src/lib_gui/qt/window/QtIndexingDialog.cpp +++ b/src/lib_gui/qt/window/QtIndexingDialog.cpp @@ -167,11 +167,6 @@ void QtIndexingDialog::updateIndexingProgress(size_t fileCount, size_t totalFile { updateMessage(QString::number(fileCount) + "/" + QString::number(totalFileCount) + " File" + (totalFileCount > 1 ? "s" : "")); - if (fileCount > 0) - { - fileCount--; - } - size_t percent = fileCount * 100 / totalFileCount; m_progressBar->showProgress(percent); m_percentLabel->setText(QString::number(percent) + "% Progress"); diff --git a/src/lib_parser/data/parser/cxx/ASTVisitor.cpp b/src/lib_parser/data/parser/cxx/ASTVisitor.cpp index 0ce430a2..cd17df55 100644 --- a/src/lib_parser/data/parser/cxx/ASTVisitor.cpp +++ b/src/lib_parser/data/parser/cxx/ASTVisitor.cpp @@ -37,6 +37,7 @@ ASTVisitor::ASTVisitor(clang::ASTContext* context, clang::Preprocessor* preproce , m_childContext(0) , m_typeContext(RT_Reference) , m_contextAccess(ACCESS_NONE) + , m_continue(true) { m_declNameCache = std::make_shared([](const clang::NamedDecl* decl) -> NameHierarchy { @@ -911,7 +912,7 @@ bool ASTVisitor::VisitDecl(clang::Decl *d) } } - return true; + return m_continue; } //#include "data/parser/ParseFunction.h" @@ -1686,3 +1687,8 @@ NameHierarchy ASTVisitor::getContextName() const } return NameHierarchy("global"); } + +void ASTVisitor::handleMessage(MessageInterruptTasks* message) +{ + m_continue = false; +} diff --git a/src/lib_parser/data/parser/cxx/ASTVisitor.h b/src/lib_parser/data/parser/cxx/ASTVisitor.h index b870523c..a093b28d 100644 --- a/src/lib_parser/data/parser/cxx/ASTVisitor.h +++ b/src/lib_parser/data/parser/cxx/ASTVisitor.h @@ -12,8 +12,12 @@ #include "data/parser/SymbolKind.h" #include "utility/file/FileRegister.h" #include "utility/Cache.h" +#include "utility/messaging/type/MessageInterruptTasks.h" +#include "utility/messaging/MessageListener.h" -class ASTVisitor: clang::RecursiveASTVisitor +class ASTVisitor + : clang::RecursiveASTVisitor + , MessageListener { public: typedef Cache DeclNameCache; @@ -224,6 +228,8 @@ private: NameHierarchy getContextName() const; + virtual void handleMessage(MessageInterruptTasks* message); + struct FileIdHash { size_t operator()(clang::FileID fileID) const { return fileID.getHashValue(); @@ -240,6 +246,7 @@ private: std::shared_ptr m_typeNameCache; AccessKind m_contextAccess; + bool m_continue; }; #endif // AST_VISITOR_H diff --git a/src/test/TaskSchedulerTestSuite.h b/src/test/TaskSchedulerTestSuite.h index 3b7becd9..87fe6cfa 100644 --- a/src/test/TaskSchedulerTestSuite.h +++ b/src/test/TaskSchedulerTestSuite.h @@ -32,16 +32,13 @@ public: int order = 0; TestTask task(&order, 1); - task.executeTask(); + executeTask(task); TS_ASSERT_EQUALS(3, order); TS_ASSERT_EQUALS(1, task.enterCallOrder); TS_ASSERT_EQUALS(2, task.updateCallOrder); TS_ASSERT_EQUALS(3, task.exitCallOrder); - TS_ASSERT_EQUALS(0, task.interruptCallOrder); - TS_ASSERT_EQUALS(0, task.revertCallOrder); - TS_ASSERT_EQUALS(0, task.abortCallOrder); } void test_scheduled_tasks_get_processed_with_callbacks_in_correct_order(void) @@ -62,34 +59,6 @@ public: TS_ASSERT_EQUALS(1, task->enterCallOrder); TS_ASSERT_EQUALS(2, task->updateCallOrder); TS_ASSERT_EQUALS(3, task->exitCallOrder); - TS_ASSERT_EQUALS(0, task->interruptCallOrder); - TS_ASSERT_EQUALS(0, task->revertCallOrder); - TS_ASSERT_EQUALS(0, task->abortCallOrder); - } - - void test_scheduled_tasks_get_interrupted_with_callbacks_in_correct_order(void) - { - TaskScheduler::getInstance()->startSchedulerLoopThreaded(); - - int order = 0; - std::shared_ptr task = std::make_shared(&order, -1); - - Task::dispatch(task); - - std::this_thread::sleep_for(std::chrono::milliseconds(50)); - - TaskScheduler::getInstance()->interruptCurrentTask(); - - waitForThread(); - - TaskScheduler::getInstance()->stopSchedulerLoop(); - - TS_ASSERT_EQUALS(1, task->enterCallOrder); - TS_ASSERT_EQUALS(order - 2, task->updateCallOrder); - TS_ASSERT_EQUALS(order - 1, task->interruptCallOrder); - TS_ASSERT_EQUALS(order, task->exitCallOrder); - TS_ASSERT_EQUALS(0, task->revertCallOrder); - TS_ASSERT_EQUALS(0, task->abortCallOrder); } void test_sequential_task_group_to_process_tasks_in_correct_order(void) @@ -115,24 +84,18 @@ public: TS_ASSERT_EQUALS(1, task1->enterCallOrder); TS_ASSERT_EQUALS(2, task1->updateCallOrder); TS_ASSERT_EQUALS(3, task1->exitCallOrder); - TS_ASSERT_EQUALS(0, task1->interruptCallOrder); - TS_ASSERT_EQUALS(0, task1->revertCallOrder); - TS_ASSERT_EQUALS(0, task1->abortCallOrder); TS_ASSERT_EQUALS(4, task2->enterCallOrder); TS_ASSERT_EQUALS(5, task2->updateCallOrder); TS_ASSERT_EQUALS(6, task2->exitCallOrder); - TS_ASSERT_EQUALS(0, task2->interruptCallOrder); - TS_ASSERT_EQUALS(0, task2->revertCallOrder); - TS_ASSERT_EQUALS(0, task2->abortCallOrder); } - void test_sequential_task_group_to_interrupt_and_revert_tasks_in_correct_order(void) + void test_sequential_task_group_does_not_evaluate_tasks_after_failure(void) { TaskScheduler::getInstance()->startSchedulerLoopThreaded(); int order = 0; - std::shared_ptr task1 = std::make_shared(&order, 1); + std::shared_ptr task1 = std::make_shared(&order, 1, Task::STATE_FAILURE); std::shared_ptr task2 = std::make_shared(&order, -1); std::shared_ptr taskGroup = std::make_shared(); @@ -141,10 +104,6 @@ public: Task::dispatch(taskGroup); - std::this_thread::sleep_for(std::chrono::milliseconds(50)); - - TaskScheduler::getInstance()->interruptCurrentTask(); - waitForThread(); TaskScheduler::getInstance()->stopSchedulerLoop(); @@ -152,77 +111,10 @@ public: TS_ASSERT_EQUALS(1, task1->enterCallOrder); TS_ASSERT_EQUALS(2, task1->updateCallOrder); TS_ASSERT_EQUALS(3, task1->exitCallOrder); - TS_ASSERT_EQUALS(0, task1->interruptCallOrder); - TS_ASSERT_EQUALS(order - 2, task1->revertCallOrder); - TS_ASSERT_EQUALS(0, task1->abortCallOrder); - TS_ASSERT_EQUALS(4, task2->enterCallOrder); - TS_ASSERT_EQUALS(order - 3, task2->updateCallOrder); - TS_ASSERT_EQUALS(order - 1, task2->interruptCallOrder); - TS_ASSERT_EQUALS(order, task2->exitCallOrder); - TS_ASSERT_EQUALS(0, task2->revertCallOrder); - TS_ASSERT_EQUALS(0, task2->abortCallOrder); - } - - void test_sequential_task_group_to_interrupt_and_revert_nested_task_groups_in_correct_order(void) - { - TaskScheduler::getInstance()->startSchedulerLoopThreaded(); - - int order = 0; - std::shared_ptr task1 = std::make_shared(&order, 1); - std::shared_ptr task2 = std::make_shared(&order, 1); - std::shared_ptr task3 = std::make_shared(&order, -1); - std::shared_ptr task4 = std::make_shared(&order, 1); - - std::shared_ptr taskGroup1 = std::make_shared(); - taskGroup1->addTask(task1); - taskGroup1->addTask(task2); - - std::shared_ptr taskGroup2 = std::make_shared(); - taskGroup2->addTask(task3); - taskGroup2->addTask(task4); - - std::shared_ptr taskGroup3 = std::make_shared(); - taskGroup3->addTask(taskGroup1); - taskGroup3->addTask(taskGroup2); - - Task::dispatch(taskGroup3); - - std::this_thread::sleep_for(std::chrono::milliseconds(50)); - - TaskScheduler::getInstance()->interruptCurrentTask(); - - waitForThread(); - - TaskScheduler::getInstance()->stopSchedulerLoop(); - - TS_ASSERT_EQUALS(1, task1->enterCallOrder); - TS_ASSERT_EQUALS(2, task1->updateCallOrder); - TS_ASSERT_EQUALS(3, task1->exitCallOrder); - TS_ASSERT_EQUALS(0, task1->interruptCallOrder); - TS_ASSERT_EQUALS(order - 3, task1->revertCallOrder); - TS_ASSERT_EQUALS(0, task1->abortCallOrder); - - TS_ASSERT_EQUALS(4, task2->enterCallOrder); - TS_ASSERT_EQUALS(5, task2->updateCallOrder); - TS_ASSERT_EQUALS(6, task2->exitCallOrder); - TS_ASSERT_EQUALS(0, task2->interruptCallOrder); - TS_ASSERT_EQUALS(order - 4, task2->revertCallOrder); - TS_ASSERT_EQUALS(0, task2->abortCallOrder); - - TS_ASSERT_EQUALS(7, task3->enterCallOrder); - TS_ASSERT_EQUALS(order - 5, task3->updateCallOrder); - TS_ASSERT_EQUALS(order - 2, task3->interruptCallOrder); - TS_ASSERT_EQUALS(order - 1, task3->exitCallOrder); - TS_ASSERT_EQUALS(0, task3->revertCallOrder); - TS_ASSERT_EQUALS(0, task3->abortCallOrder); - - TS_ASSERT_EQUALS(0, task4->enterCallOrder); - TS_ASSERT_EQUALS(0, task4->updateCallOrder); - TS_ASSERT_EQUALS(0, task4->exitCallOrder); - TS_ASSERT_EQUALS(0, task4->interruptCallOrder); - TS_ASSERT_EQUALS(0, task4->revertCallOrder); - TS_ASSERT_EQUALS(order, task4->abortCallOrder); + TS_ASSERT_EQUALS(0, task2->enterCallOrder); + TS_ASSERT_EQUALS(0, task2->updateCallOrder); + TS_ASSERT_EQUALS(0, task2->exitCallOrder); } void test_task_scheduling_within_task_processing() @@ -243,39 +135,44 @@ public: TS_ASSERT_EQUALS(1, task->enterCallOrder); TS_ASSERT_EQUALS(2, task->updateCallOrder); TS_ASSERT_EQUALS(3, task->exitCallOrder); - TS_ASSERT_EQUALS(0, task->interruptCallOrder); - TS_ASSERT_EQUALS(0, task->revertCallOrder); TS_ASSERT_EQUALS(4, task->subTask->enterCallOrder); TS_ASSERT_EQUALS(5, task->subTask->updateCallOrder); TS_ASSERT_EQUALS(6, task->subTask->exitCallOrder); - TS_ASSERT_EQUALS(0, task->subTask->interruptCallOrder); - TS_ASSERT_EQUALS(0, task->subTask->revertCallOrder); } private: + void executeTask(Task& task) + { + while (true) + { + if (task.update() != Task::STATE_RUNNING) + { + return; + } + } + } class TestTask: public Task { public: - TestTask(int* orderCountPtr, int updateCount) + TestTask(int* orderCountPtr, int updateCount, TaskState returnState = STATE_SUCCESS) : orderCount(*orderCountPtr) , updateCount(updateCount) + , returnState(returnState) , enterCallOrder(0) , updateCallOrder(0) , exitCallOrder(0) - , interruptCallOrder(0) - , revertCallOrder(0) - , abortCallOrder(0) + , resetCallOrder(0) { } - virtual void enter() + virtual void doEnter() { enterCallOrder = ++orderCount; } - virtual TaskState update() + virtual TaskState doUpdate() { updateCallOrder = ++orderCount; @@ -291,38 +188,27 @@ private: return Task::STATE_RUNNING; } - return Task::STATE_FINISHED; + return returnState; } - virtual void exit() + virtual void doExit() { exitCallOrder = ++orderCount; } - virtual void interrupt() + virtual void doReset() { - interruptCallOrder = ++orderCount; - } - - virtual void revert() - { - revertCallOrder = ++orderCount; - } - - virtual void abort() - { - abortCallOrder = ++orderCount; + resetCallOrder = ++orderCount; } int& orderCount; int updateCount; + TaskState returnState; int enterCallOrder; int updateCallOrder; int exitCallOrder; - int interruptCallOrder; - int revertCallOrder; - int abortCallOrder; + int resetCallOrder; }; class TestTaskDispatch: public TestTask @@ -333,12 +219,12 @@ private: { } - virtual TaskState update() + virtual TaskState doUpdate() { subTask = std::make_shared(&orderCount, 1); Task::dispatch(subTask); - return TestTask::update(); + return TestTask::doUpdate(); } std::shared_ptr subTask; diff --git a/src/trial/data/parser/cxx/TaskParseCxx.cpp b/src/trial/data/parser/cxx/TaskParseCxx.cpp index 4533f438..b96f0f50 100644 --- a/src/trial/data/parser/cxx/TaskParseCxx.cpp +++ b/src/trial/data/parser/cxx/TaskParseCxx.cpp @@ -1,8 +1,7 @@ #include "data/parser/cxx/TaskParseCxx.h" TaskParseCxx::TaskParseCxx( - PersistentStorage* storage, - std::shared_ptr storageMutex, + std::shared_ptr storage, std::shared_ptr fileRegister, const Parser::Arguments& arguments, DialogView* dialogView @@ -15,27 +14,23 @@ std::vector TaskParseCxx::getSourceFilesFromCDB(const FilePath& compil return std::vector(); } -void TaskParseCxx::enter() +void TaskParseCxx::doEnter() { } -Task::TaskState TaskParseCxx::update() +Task::TaskState TaskParseCxx::doUpdate() { - return Task::STATE_FINISHED; + return STATE_SUCCESS; } -void TaskParseCxx::exit() +void TaskParseCxx::doExit() { } -void TaskParseCxx::interrupt() +void TaskParseCxx::doReset() { } -void TaskParseCxx::revert() -{ -} - -void TaskParseCxx::abort() +void TaskParseCxx::handleMessage(MessageInterruptTasks* message) { } diff --git a/src/trial/data/parser/cxx/TaskParseWrapper.cpp b/src/trial/data/parser/cxx/TaskParseWrapper.cpp index 1bb77cd2..1254fbd9 100644 --- a/src/trial/data/parser/cxx/TaskParseWrapper.cpp +++ b/src/trial/data/parser/cxx/TaskParseWrapper.cpp @@ -16,40 +16,23 @@ TaskParseWrapper::~TaskParseWrapper() { } -void TaskParseWrapper::enter() +void TaskParseWrapper::setTask(std::shared_ptr task) { - m_storage->startParsing(); - - m_task->enter(); } -Task::TaskState TaskParseWrapper::update() +void TaskParseWrapper::doEnter() { - return m_task->update(); } -void TaskParseWrapper::exit() +Task::TaskState TaskParseWrapper::doUpdate() { - m_task->exit(); - - m_storage->finishParsing(); - - MessageFinishedParsing().dispatch(); + return STATE_SUCCESS; } -void TaskParseWrapper::interrupt() +void TaskParseWrapper::doExit() { - m_task->interrupt(); } -void TaskParseWrapper::revert() +void TaskParseWrapper::doReset() { - m_task->revert(); -} - -void TaskParseWrapper::abort() -{ - m_task->abort(); - - MessageFinishedParsing().dispatch(); } diff --git a/src/trial/data/parser/java/TaskParseJava.cpp b/src/trial/data/parser/java/TaskParseJava.cpp index c22ac081..f87a93d6 100644 --- a/src/trial/data/parser/java/TaskParseJava.cpp +++ b/src/trial/data/parser/java/TaskParseJava.cpp @@ -1,8 +1,7 @@ #include "data/parser/java/TaskParseJava.h" TaskParseJava::TaskParseJava( - PersistentStorage* storage, - std::shared_ptr storageMutex, + std::shared_ptr storage, std::shared_ptr fileRegister, const Parser::Arguments& arguments, DialogView* dialogView @@ -10,27 +9,23 @@ TaskParseJava::TaskParseJava( { } -void TaskParseJava::enter() +void TaskParseJava::doEnter() { } -Task::TaskState TaskParseJava::update() +Task::TaskState TaskParseJava::doUpdate() { - return Task::STATE_FINISHED; + return STATE_SUCCESS; } -void TaskParseJava::exit() +void TaskParseJava::doExit() { } -void TaskParseJava::interrupt() +void TaskParseJava::doReset() { } -void TaskParseJava::revert() -{ -} - -void TaskParseJava::abort() +void TaskParseJava::handleMessage(MessageInterruptTasks* message) { }