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

@@ -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<FilePath> TaskParseCxx::getSourceFilesFromCDB(const FilePath& compil
 }
 
 TaskParseCxx::TaskParseCxx(
-	PersistentStorage* storage,
+	std::shared_ptr<IntermediateStorage> storage,
-	std::shared_ptr<std::mutex> storageMutex,
 	std::shared_ptr<FileRegister> 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<CxxParser>(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(
+		m_storage->clear();
-		fileRegister->getParsedSourceFilesCount(), fileRegister->getSourceFilesCount(), sourcePath.str());
+		m_parserClient->setStorage(m_storage);
+		m_parserClient->startParsingFile();
 
-	std::shared_ptr<IntermediateStorage> intermediateStorage = std::make_shared<IntermediateStorage>();
+		if (m_isCDB)
-
-	m_parserClient->setStorage(intermediateStorage);
-	m_parserClient->startParsingFile();
-
-	if (m_isCDB)
-	{
-		std::vector<clang::tooling::CompileCommand> commands = m_cdb->getCompileCommands(sourcePath.str());
-		if (commands.size() > 0)
 		{
-			m_parser->runTool(commands[0], m_arguments);
+			std::vector<clang::tooling::CompileCommand> commands = m_cdb->getCompileCommands(sourcePath.str());
+			if (commands.size() > 0)
+			{
+				m_parser->runTool(commands[0], m_arguments);
+			}
+		}
+		else
+		{
+			m_parser->runTool(std::vector<std::string>(1, sourcePath.str()));
+		}
+
+		m_parserClient->finishParsingFile();
+		m_parserClient->resetStorage();
+
+		if (!m_interrupted)
+		{
+			fileRegister->markThreadFilesParsed();
 		}
 	}
-	else
-	{
-		m_parser->runTool(std::vector<std::string>(1, sourcePath.str()));
-	}
 
-	m_parserClient->finishParsingFile();
+	return (m_interrupted ? STATE_FAILURE : STATE_SUCCESS);
-	m_parserClient->resetStorage();
-
-	{
-		std::lock_guard<std::mutex> lock(*(m_storageMutex.get()));
-		m_storage->inject(intermediateStorage.get());
-	}
-
-	fileRegister->markThreadFilesParsed();
-
-	return Task::STATE_RUNNING;
 }
 
-void TaskParseCxx::exit()
+void TaskParseCxx::doExit()
 {
 }
 
-void TaskParseCxx::interrupt()
+void TaskParseCxx::doReset()
 {
 }
 
-void TaskParseCxx::revert()
+void TaskParseCxx::handleMessage(MessageInterruptTasks* message)
-{
-}
-
-void TaskParseCxx::abort()
 {
+	m_interrupted = true;
 }

src/app/data/parser/cxx/TaskParseWrapper.cpp

@@ -21,25 +21,29 @@ TaskParseWrapper::~TaskParseWrapper()
 {
 }
 
-void TaskParseWrapper::enter()
+void TaskParseWrapper::setTask(std::shared_ptr<Task> task)
+{
+	if (task)
+	{
+		m_taskRunner = std::make_shared<TaskRunner>(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();
+	m_taskRunner->reset();
-}
-
-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()
-	);
 }

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<IntermediateStorage> storage,
-	std::shared_ptr<std::mutex> storageMutex,
 	std::shared_ptr<FileRegister> 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<ParserClientImpl> parserClient = std::make_shared<ParserClientImpl>();
 	std::shared_ptr<JavaParser> parser = std::make_shared<JavaParser>(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(
+	return (m_interrupted ? STATE_FAILURE : STATE_SUCCESS);
-		m_fileRegister->getParsedSourceFilesCount(), m_fileRegister->getSourceFilesCount(), sourcePath.str());
-
-	std::shared_ptr<IntermediateStorage> intermediateStorage = std::make_shared<IntermediateStorage>();
-
-	parserClient->setStorage(intermediateStorage);
-	parserClient->startParsingFile();
-
-	parser->parseFile(sourcePath, TextAccess::createFromFile(sourcePath.str()), m_arguments);
-
-	parserClient->finishParsingFile();
-	parserClient->resetStorage();
-
-	{
-		std::lock_guard<std::mutex> lock(*(m_storageMutex.get()));
-		m_storage->inject(intermediateStorage.get());
-	}
-
-	m_fileRegister->markThreadFilesParsed(); // todo: rename to markThreadFilesProcessed
-
-	return Task::STATE_RUNNING;
 }
 
-void TaskParseJava::exit()
+void TaskParseJava::doExit()
 {
 }
 
-void TaskParseJava::interrupt()
+void TaskParseJava::doReset()
 {
 }
 
-void TaskParseJava::revert()
+void TaskParseJava::handleMessage(MessageInterruptTasks* message)
-{
-}
-
-void TaskParseJava::abort()
 {
+	m_interrupted = true;
 }

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
 

src/lib/CxxProject.cpp

@@ -54,13 +54,11 @@ bool CxxProject::prepareRefresh()
 }
 
 std::shared_ptr<Task> CxxProject::createIndexerTask(
-	PersistentStorage* storage,
+	std::shared_ptr<IntermediateStorage> storage,
-	std::shared_ptr<std::mutex> storageMutex,
 	std::shared_ptr<FileRegister> fileRegister)
 {
 	return std::make_shared<TaskParseCxx>(
 		storage,
-		storageMutex,
 		fileRegister,
 		getParserArguments(),
 		getDialogView()

src/lib/CxxProject.h

@@ -26,8 +26,7 @@ private:
 	virtual bool prepareRefresh();
 
 	virtual std::shared_ptr<Task> createIndexerTask(
-		PersistentStorage* storage,
+		std::shared_ptr<IntermediateStorage> storage,
-		std::shared_ptr<std::mutex> storageMutex,
 		std::shared_ptr<FileRegister> fileRegister);
 
 	virtual void updateFileManager(FileManager& fileManager);

src/lib/JavaProject.cpp

@@ -76,8 +76,7 @@ bool JavaProject::prepareIndexing()
 }
 
 std::shared_ptr<Task> JavaProject::createIndexerTask(
-	PersistentStorage* storage,
+	std::shared_ptr<IntermediateStorage> storage,
-	std::shared_ptr<std::mutex> storageMutex,
 	std::shared_ptr<FileRegister> fileRegister)
 {
 	Parser::Arguments arguments;
@@ -100,7 +99,6 @@ std::shared_ptr<Task> JavaProject::createIndexerTask(
 
 	return std::make_shared<TaskParseJava>(
 		storage,
-		storageMutex,
 		fileRegister,
 		arguments,
 		getDialogView()

src/lib/JavaProject.h

@@ -26,8 +26,7 @@ private:
 	virtual bool prepareIndexing();
 
 	virtual std::shared_ptr<Task> createIndexerTask(
-		PersistentStorage* storage,
+		std::shared_ptr<IntermediateStorage> storage,
-		std::shared_ptr<std::mutex> storageMutex,
 		std::shared_ptr<FileRegister> fileRegister);
 
 	virtual void updateFileManager(FileManager& fileManager);

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<TaskRepeatWhileUnparsedSourceFilesAvailable> taskRepeat = std::make_shared<TaskRepeatWhileUnparsedSourceFilesAvailable>(fileRegister);
+		taskParallelIndexing->addTask(taskRepeat);
+
+		std::shared_ptr<TaskGroupSequential> taskRepeatSequential = std::make_shared<TaskGroupSequential>();
+		taskRepeat->setTask(taskRepeatSequential);
+
+		std::shared_ptr<IntermediateStorage> intermediateStorage = std::make_shared<IntermediateStorage>();
+
+		taskRepeatSequential->addTask(createIndexerTask(intermediateStorage, fileRegister));
+		taskRepeatSequential->addTask(std::make_shared<TaskInjectStorage>(intermediateStorage, m_storage));
 	}
 
 	Task::dispatch(taskSequential);

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<Task> createIndexerTask(
-		PersistentStorage* storage,
+		std::shared_ptr<IntermediateStorage> storage,
-		std::shared_ptr<std::mutex> storageMutex,
 		std::shared_ptr<FileRegister> fileRegister) = 0;
 	virtual void updateFileManager(FileManager& fileManager) = 0;
 

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<StorageFile> file = std::make_shared<StorageFile>(0, name, filePath, modificationTime);

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<StorageCommentLocation> m_commentLocations;
 	std::vector<StorageError> m_errors;
 
-	std::unordered_map<Id, Id> m_nodeIdsToMemberEdgeIds;
-
 	Id m_nextId;
 };
 

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<std::mutex> lock(m_dataMutex);
 
+	TRACE();
 	startInjection();
 
 	std::unordered_map<Id, Id> 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
+}

src/lib/data/Storage.h

@@ -2,6 +2,7 @@
 #define STORAGE_H
 
 #include <functional>
+#include <mutex>
 #include <string>
 
 #include "data/name/NameHierarchy.h"
@@ -32,9 +33,13 @@ public:
 	virtual void forEachCommentLocation(std::function<void(const StorageCommentLocation& /*data*/)> callback) const = 0;
 	virtual void forEachError(std::function<void(const StorageError& /*data*/)> 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

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::doReset()
-{
-}
-
-void TaskCleanStorage::revert()
-{
-}
-
-void TaskCleanStorage::abort()
 {
 }

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<FilePath> m_filePaths;
 	DialogView* m_dialogView;
 };
 
-#endif // TASK_PARSE_CXX_H
+#endif // TASK_CLEAN_STORAGE_H

src/lib/data/TaskInjectStorage.cpp

@@ -0,0 +1,30 @@
+#include "data/TaskInjectStorage.h"
+
+#include "data/Storage.h"
+
+TaskInjectStorage::TaskInjectStorage(
+	std::shared_ptr<Storage> source,
+	std::shared_ptr<Storage> 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()
+{
+}

src/lib/data/TaskInjectStorage.h

@@ -0,0 +1,29 @@
+#ifndef TASK_INJECT_STORAGE_H
+#define TASK_INJECT_STORAGE_H
+
+#include <vector>
+
+#include "utility/scheduling/Task.h"
+
+class Storage;
+
+class TaskInjectStorage
+	: public Task
+{
+public:
+	TaskInjectStorage(
+		std::shared_ptr<Storage> source,
+		std::shared_ptr<Storage> target
+	);
+
+private:
+	virtual void doEnter();
+	virtual TaskState doUpdate();
+	virtual void doExit();
+	virtual void doReset();
+
+	std::shared_ptr<Storage> m_source;
+	std::shared_ptr<Storage> m_target;
+};
+
+#endif // TASK_INJECT_STORAGE_H

src/lib/data/TaskRepeatWhileUnparsedSourceFilesAvailable.cpp

@@ -0,0 +1,47 @@
+#include "data/TaskRepeatWhileUnparsedSourceFilesAvailable.h"
+
+#include "utility/file/FileRegister.h"
+
+TaskRepeatWhileUnparsedSourceFilesAvailable::TaskRepeatWhileUnparsedSourceFilesAvailable(
+	std::shared_ptr<FileRegister> fileRegister
+)
+	: m_fileRegister(fileRegister)
+{
+}
+
+void TaskRepeatWhileUnparsedSourceFilesAvailable::setTask(std::shared_ptr<Task> task)
+{
+	if (task)
+	{
+		m_taskRunner = std::make_shared<TaskRunner>(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();
+}

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 <vector>
+
+#include "utility/scheduling/TaskDecorator.h"
+#include "utility/scheduling/TaskRunner.h"
+
+class FileRegister;
+
+class TaskRepeatWhileUnparsedSourceFilesAvailable
+	: public TaskDecorator
+{
+public:
+	TaskRepeatWhileUnparsedSourceFilesAvailable(
+		std::shared_ptr<FileRegister> fileRegister
+	);
+
+	virtual void setTask(std::shared_ptr<Task> task);
+
+private:
+	virtual void doEnter();
+	virtual TaskState doUpdate();
+	virtual void doExit();
+	virtual void doReset();
+
+	std::shared_ptr<FileRegister> m_fileRegister;
+	std::shared_ptr<TaskRunner> m_taskRunner;
+};
+
+#endif // TASK_REPEAT_WHILE_UNPARSED_SOURCE_FILES_AVAILABLE_H

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<MessageInterruptTasks>
 {
 public:
 	static std::vector<FilePath> getSourceFilesFromCDB(const FilePath& compilationDatabasePath);
 
 	TaskParseCxx(
-		PersistentStorage* storage,
+		std::shared_ptr<IntermediateStorage> storage,
-		std::shared_ptr<std::mutex> storageMutex,
 		std::shared_ptr<FileRegister> 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<IntermediateStorage> m_storage;
 	std::shared_ptr<std::mutex> m_storageMutex;
 
 	const Parser::Arguments m_arguments;
@@ -57,6 +58,8 @@ private:
 
 	bool m_isCDB;
 	std::shared_ptr<clang::tooling::JSONCompilationDatabase> m_cdb;
+
+	bool m_interrupted;
 };
 
 #endif // TASK_PARSE_CXX_H

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 void setTask(std::shared_ptr<Task> task);
-	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::shared_ptr<FileRegister> m_fileRegister;
 	DialogView* m_dialogView;
 
 	TimePoint m_start;
+	std::shared_ptr<TaskRunner> m_taskRunner;
 };
 
 #endif // TASK_PARSE_WRAPPER_H

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<MessageInterruptTasks>
 {
 public:
 	TaskParseJava(
-		PersistentStorage* storage,
+		std::shared_ptr<IntermediateStorage> storage,
-		std::shared_ptr<std::mutex> storageMutex,
 		std::shared_ptr<FileRegister> 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();
-	std::shared_ptr<std::mutex> m_storageMutex;
+	virtual TaskState doUpdate();
+	virtual void doExit();
+	virtual void doReset();
+
+	virtual void handleMessage(MessageInterruptTasks* message);
+
+	std::shared_ptr<IntermediateStorage> m_storage;
 	std::shared_ptr<FileRegister> m_fileRegister;
 	Parser::Arguments m_arguments;
 	DialogView* m_dialogView;
+
+	bool m_interrupted;
 };
 
 #endif // TASK_PARSE_JAVA_H

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<std::mutex> lock(m_sourceFileMutex);
+
+	size_t count = 0;
+
+	for (std::pair<FilePath, ParseState>&& p : m_sourceFilePaths)
+	{
+		if (p.second == STATE_PARSED)
+		{
+			count++;
+		}
+	}
+
+	return count;
 }

src/lib/utility/messaging/MessageQueue.cpp

@@ -260,24 +260,26 @@ void MessageQueue::sendMessageAsTask(std::shared_ptr<MessageBase> message, bool
 {
 	std::shared_ptr<TaskGroupSequential> taskGroup = std::make_shared<TaskGroupSequential>();
 
-	std::lock_guard<std::mutex> lock(m_listenersMutex);
-	for (size_t i = 0; i < m_listeners.size(); i++)
 	{
-		MessageListenerBase* listener = m_listeners[i];
+		std::lock_guard<std::mutex> lock(m_listenersMutex);
-
+		for (size_t i = 0; i < m_listeners.size(); i++)
-		if (listener->getType() == message->getType())
 		{
-			uint listenerId = listener->getId();
+			MessageListenerBase* listener = m_listeners[i];
-			taskGroup->addTask(std::make_shared<TaskLambda>(
+
-				[listenerId, message]()
+			if (listener->getType() == message->getType())
-				{
+			{
-					MessageListenerBase* listener = MessageQueue::getInstance()->getListenerById(listenerId);
+				uint listenerId = listener->getId();
-					if (listener)
+				taskGroup->addTask(std::make_shared<TaskLambda>(
+					[listenerId, message]()
 					{
-						listener->handleMessageBase(message.get());
+						MessageListenerBase* listener = MessageQueue::getInstance()->getListenerById(listenerId);
+						if (listener)
+						{
+							listener->handleMessageBase(message.get());
+						}
 					}
-				}
+				));
-			));
+			}
 		}
 	}
 

src/lib/utility/scheduling/Task.cpp

@@ -14,7 +14,8 @@ void Task::dispatchNext(std::shared_ptr<Task> 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;
+	if (!m_enterCalled)
-}
-
-Task::TaskState Task::processTask()
-{
-	switch (m_state)
 	{
-	case STATE_NEW:
+		doEnter();
-	case STATE_CANCELED:
+		m_enterCalled = true;
-		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;
 	}
 
-	return m_state;
+	TaskState state = doUpdate();
-}
 
-Task::TaskState Task::interruptTask()
+	if (state != STATE_RUNNING && !m_exitCalled)
-{
-	switch (m_state)
 	{
-	case STATE_NEW:
+		doExit();
-		abort();
+		m_exitCalled = true;
-		break;
-	case STATE_CANCELED:
-		break;
-	case STATE_RUNNING:
-		interrupt();
-		exit();
-		break;
-	case STATE_FINISHED:
-		revert();
-		break;
 	}
 
-	setState(STATE_CANCELED);
+	return state;
-	return m_state;
 }
 
-void Task::executeTask()
+void Task::reset()
 {
-	TaskState state;
+	doReset();
-	do
+	m_enterCalled = false;
-	{
+	m_exitCalled = false;
-		state = processTask();
-	}
-	while (state != STATE_FINISHED);
-}
-
-void Task::setState(TaskState state)
-{
-	m_state = state;
 }

src/lib/utility/scheduling/Task.h

@@ -8,10 +8,9 @@ class Task
 public:
 	enum TaskState
 	{
-		STATE_NEW,
 		STATE_RUNNING,
-		STATE_FINISHED,
+		STATE_SUCCESS,
-		STATE_CANCELED
+		STATE_FAILURE
 	};
 
 	static void dispatch(std::shared_ptr<Task> task);
@@ -20,26 +19,19 @@ public:
 	Task();
 	virtual ~Task();
 
-	TaskState getState() const;
+//	virtual TaskState getState() const = 0;
 
-	TaskState processTask();
+	TaskState update();
-	TaskState interruptTask();
+	void reset();
-
-	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);
 
 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

src/lib/utility/scheduling/TaskDecorator.cpp

@@ -7,8 +7,3 @@ TaskDecorator::TaskDecorator()
 TaskDecorator::~TaskDecorator()
 {
 }
-
-void TaskDecorator::setTask(std::shared_ptr<Task> task)
-{
-	m_task = task;
-}

src/lib/utility/scheduling/TaskDecorator.h

@@ -12,10 +12,7 @@ public:
 	TaskDecorator();
 	virtual ~TaskDecorator();
 
-	void setTask(std::shared_ptr<Task> task);
+	virtual void setTask(std::shared_ptr<Task> task) = 0;
-
-protected:
-	std::shared_ptr<Task> m_task;
 };
 
 #endif // TASK_DECORATOR_H

src/lib/utility/scheduling/TaskGroup.cpp

@@ -7,8 +7,3 @@ TaskGroup::TaskGroup()
 TaskGroup::~TaskGroup()
 {
 }
-
-void TaskGroup::addTask(std::shared_ptr<Task> task)
-{
-	m_tasks.push_back(task);
-}

src/lib/utility/scheduling/TaskGroup.h

@@ -13,10 +13,7 @@ public:
 	TaskGroup();
 	virtual ~TaskGroup();
 
-	void addTask(std::shared_ptr<Task> task);
+	virtual void addTask(std::shared_ptr<Task> task) = 0;
-
-protected:
-	std::vector<std::shared_ptr<Task>> m_tasks;
 };
 
 #endif // TASK_GROUP_H

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> task)
 {
-	m_interrupt = false;
+	m_tasks.push_back(std::make_shared<TaskInfo>(std::make_shared<TaskRunner>(task)));
-	m_running = false;
-	m_activeTaskCount = 0;
 }
 
-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]));
+			m_tasks[i]->thread = std::make_shared<std::thread>(&TaskGroupParallel::processTaskThreaded, this, m_tasks[i]);
-
+			m_tasks[i]->active = true;
-			std::lock_guard<std::mutex> lock(m_activeTaskCountMutex);
 			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<std::mutex> lock(m_activeTaskCountMutex);
+		m_tasks[i]->thread->join();
-		activeTaskCount = m_activeTaskCount;
+		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);
+		m_tasks[i]->taskRunner->reset();
-	}
+		if (!m_tasks[i]->active)
-
-	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)
-{
-	Task::TaskState state = Task::STATE_NEW;
-	while (state != Task::STATE_FINISHED && state != Task::STATE_CANCELED)
-	{
-		if (m_interrupt)
 		{
-			state = task->interruptTask();
+			m_tasks[i]->thread->join();
-		}
+			m_tasks[i]->thread = std::make_shared<std::thread>(&TaskGroupParallel::processTaskThreaded, this, m_tasks[i]);
-		else
+			m_tasks[i]->active = true;
-		{
+			m_activeTaskCount++;
-			state = task->processTask();
 		}
 	}
+}
 
-	{
+void TaskGroupParallel::processTaskThreaded(std::shared_ptr<TaskInfo> taskInfo)
+{
+	ScopedFunctor functor([&](){
 		std::lock_guard<std::mutex> 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<std::mutex> lock(m_activeTaskCountMutex);
+	return m_activeTaskCount;
+}

src/lib/utility/scheduling/TaskGroupParallel.h

@@ -1,10 +1,12 @@
 #ifndef TASK_GROUP_PARALLEL_H
 #define TASK_GROUP_PARALLEL_H
 
+#include <map>
 #include <mutex>
 #include <thread>
 
 #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 void addTask(std::shared_ptr<Task> task);
-	virtual TaskState update();
-	virtual void exit();
-
-	virtual void interrupt();
-	virtual void revert();
-	virtual void abort();
 
 private:
-	void processTaskThreaded(std::shared_ptr<Task> task);
+	struct TaskInfo
+	{
+		TaskInfo(std::shared_ptr<TaskRunner> taskRunner)
+			: taskRunner(taskRunner)
+			, active(false)
+		{}
+		std::shared_ptr<TaskRunner> taskRunner;
+		std::shared_ptr<std::thread> thread;
+		volatile bool active;
+	};
 
-	volatile bool m_interrupt;
+	virtual void doEnter();
-	bool m_running;
+	virtual TaskState doUpdate();
+	virtual void doExit();
+	virtual void doReset();
 
-	std::vector<std::thread> m_threads;
+	void processTaskThreaded(std::shared_ptr<TaskInfo> taskInfo);
+	int getActveTaskCount() const;
 
+	std::vector<std::shared_ptr<TaskInfo>> 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

src/lib/utility/scheduling/TaskGroupSequential.cpp

@@ -1,7 +1,7 @@
 #include "utility/scheduling/TaskGroupSequential.h"
+#include <iostream>
 
 TaskGroupSequential::TaskGroupSequential()
-	: m_taskIndex(-1)
 {
 }
 
@@ -9,55 +9,49 @@ TaskGroupSequential::~TaskGroupSequential()
 {
 }
 
-void TaskGroupSequential::enter()
+void TaskGroupSequential::addTask(std::shared_ptr<Task> task)
 {
+	m_taskRunners.push_back(std::make_shared<TaskRunner>(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++;
 	}
-
+	else if (state == STATE_FAILURE)
-	std::shared_ptr<Task> task = m_tasks[m_taskIndex];
-
-	TaskState state = task->processTask();
-
-	if (state == Task::STATE_FINISHED && size_t(m_taskIndex + 1) == m_tasks.size())
 	{
-		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();
-}

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 void addTask(std::shared_ptr<Task> task);
-	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::vector<std::shared_ptr<TaskRunner>> m_taskRunners;
 	int m_taskIndex;
 };
 

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::doReset()
-{
-}
-
-void TaskLambda::revert()
-{
-}
-
-void TaskLambda::abort()
 {
 }

src/lib/utility/scheduling/TaskLambda.h

@@ -12,15 +12,12 @@ public:
 	TaskLambda(std::function<void()> 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<void()> m_func;
 };
 

src/lib/utility/scheduling/TaskRunner.cpp

@@ -0,0 +1,34 @@
+#include "utility/scheduling/TaskRunner.h"
+
+TaskRunner::TaskRunner(std::shared_ptr<Task> 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;
+}
+
+

src/lib/utility/scheduling/TaskRunner.h

@@ -0,0 +1,24 @@
+#ifndef TASK_RUNNER_H
+#define TASK_RUNNER_H
+
+#include <memory>
+
+#include "utility/scheduling/Task.h"
+
+class TaskRunner
+{
+public:
+	TaskRunner(std::shared_ptr<Task> task);
+	~TaskRunner();
+
+	//Task::TaskState getState() const;
+
+	Task::TaskState update();
+	void reset();
+
+private:
+	std::shared_ptr<Task> m_task;
+	bool m_reset;
+};
+
+#endif // TASK_H

src/lib/utility/scheduling/TaskScheduler.cpp

@@ -19,29 +19,23 @@ std::shared_ptr<TaskScheduler> TaskScheduler::getInstance()
 void TaskScheduler::pushTask(std::shared_ptr<Task> task)
 {
 	std::lock_guard<std::mutex> lock(m_tasksMutex);
-	m_tasks.push_back(task);
+	m_taskRunners.push_back(std::make_shared<TaskRunner>(task));
 }
 
 void TaskScheduler::pushNextTask(std::shared_ptr<Task> task)
 {
 	std::lock_guard<std::mutex> 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<TaskRunner>(task));
 	}
 	else
 	{
-		m_tasks.insert(m_tasks.begin() + 1, task);
+		m_taskRunners.insert(m_taskRunners.begin() + 1, std::make_shared<TaskRunner>(task));
 	}
 }
 
-void TaskScheduler::interruptCurrentTask()
-{
-	std::lock_guard<std::mutex> 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<std::mutex> lock(m_tasksMutex);
-	return m_tasks.size();
+	return m_taskRunners.size();
 }
 
 std::shared_ptr<TaskScheduler> TaskScheduler::s_instance;
@@ -137,7 +129,6 @@ std::shared_ptr<TaskScheduler> TaskScheduler::s_instance;
 TaskScheduler::TaskScheduler()
 	: m_loopIsRunning(false)
 	, m_threadIsRunning(false)
-	, m_interruptTask(false)
 {
 }
 
@@ -145,41 +136,19 @@ void TaskScheduler::processTasks()
 {
 	std::lock_guard<std::mutex> lock(m_tasksMutex);
 
-	while (m_tasks.size())
+	while (m_taskRunners.size())
 	{
-		bool interrupt = m_interruptTask;
+		std::shared_ptr<TaskRunner> runner = m_taskRunners.front();
-		m_interruptTask = false;
-
-		std::shared_ptr<Task> task = m_tasks.front();
-		Task::TaskState state;
 
 		m_tasksMutex.unlock();
-		if (interrupt)
+
-		{
+		Task::TaskState state = runner->update();
-			state = task->interruptTask();
+
-		}
-		else
-		{
-			state = task->processTask();
-		}
 		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<std::mutex> lock(m_tasksMutex);
-	if (m_tasks.size())
-	{
-		MessageStatus("Stop running tasks...", false, true).dispatch();
-	}
 }

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<MessageInterruptTasks>
 {
 public:
 	static std::shared_ptr<TaskScheduler> getInstance();
 
 	void pushTask(std::shared_ptr<Task> task);
 	void pushNextTask(std::shared_ptr<Task> 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<std::shared_ptr<Task>> m_tasks;
+	std::deque<std::shared_ptr<TaskRunner>> m_taskRunners;
-	bool m_interruptTask;
 
 	mutable std::mutex m_tasksMutex;
 	mutable std::mutex m_loopMutex;

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");

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<DeclNameCache>([](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;
+}

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<ASTVisitor>
+class ASTVisitor
+	: clang::RecursiveASTVisitor<ASTVisitor>
+	, MessageListener<MessageInterruptTasks>
 {
 public:
 	typedef Cache<const clang::NamedDecl*, NameHierarchy> 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<TypeNameCache> m_typeNameCache;
 
 	AccessKind m_contextAccess;
+	bool m_continue;
 };
 
 #endif // AST_VISITOR_H

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<TestTask> task = std::make_shared<TestTask>(&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<TestTask> task1 = std::make_shared<TestTask>(&order, 1);
+		std::shared_ptr<TestTask> task1 = std::make_shared<TestTask>(&order, 1, Task::STATE_FAILURE);
 		std::shared_ptr<TestTask> task2 = std::make_shared<TestTask>(&order, -1);
 
 		std::shared_ptr<TaskGroupSequential> taskGroup = std::make_shared<TaskGroupSequential>();
@@ -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(0, task2->enterCallOrder);
-		TS_ASSERT_EQUALS(order - 3, task2->updateCallOrder);
+		TS_ASSERT_EQUALS(0, task2->updateCallOrder);
-		TS_ASSERT_EQUALS(order - 1, task2->interruptCallOrder);
+		TS_ASSERT_EQUALS(0, task2->exitCallOrder);
-		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<TestTask> task1 = std::make_shared<TestTask>(&order, 1);
-		std::shared_ptr<TestTask> task2 = std::make_shared<TestTask>(&order, 1);
-		std::shared_ptr<TestTask> task3 = std::make_shared<TestTask>(&order, -1);
-		std::shared_ptr<TestTask> task4 = std::make_shared<TestTask>(&order, 1);
-
-		std::shared_ptr<TaskGroupSequential> taskGroup1 = std::make_shared<TaskGroupSequential>();
-		taskGroup1->addTask(task1);
-		taskGroup1->addTask(task2);
-
-		std::shared_ptr<TaskGroupSequential> taskGroup2 = std::make_shared<TaskGroupSequential>();
-		taskGroup2->addTask(task3);
-		taskGroup2->addTask(task4);
-
-		std::shared_ptr<TaskGroupSequential> taskGroup3 = std::make_shared<TaskGroupSequential>();
-		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);
 	}
 
 	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)
+			, resetCallOrder(0)
-			, revertCallOrder(0)
-			, abortCallOrder(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;
+			resetCallOrder = ++orderCount;
-		}
-
-		virtual void revert()
-		{
-			revertCallOrder = ++orderCount;
-		}
-
-		virtual void abort()
-		{
-			abortCallOrder = ++orderCount;
 		}
 
 		int& orderCount;
 		int updateCount;
+		TaskState returnState;
 
 		int enterCallOrder;
 		int updateCallOrder;
 		int exitCallOrder;
-		int interruptCallOrder;
+		int resetCallOrder;
-		int revertCallOrder;
-		int abortCallOrder;
 	};
 
 	class TestTaskDispatch: public TestTask
@@ -333,12 +219,12 @@ private:
 		{
 		}
 
-		virtual TaskState update()
+		virtual TaskState doUpdate()
 		{
 			subTask = std::make_shared<TestTask>(&orderCount, 1);
 			Task::dispatch(subTask);
 
-			return TestTask::update();
+			return TestTask::doUpdate();
 		}
 
 		std::shared_ptr<TestTask> subTask;

src/trial/data/parser/cxx/TaskParseCxx.cpp

@@ -1,8 +1,7 @@
 #include "data/parser/cxx/TaskParseCxx.h"
 
 TaskParseCxx::TaskParseCxx(
-	PersistentStorage* storage,
+	std::shared_ptr<IntermediateStorage> storage,
-	std::shared_ptr<std::mutex> storageMutex,
 	std::shared_ptr<FileRegister> fileRegister,
 	const Parser::Arguments& arguments,
 	DialogView* dialogView
@@ -15,27 +14,23 @@ std::vector<FilePath> TaskParseCxx::getSourceFilesFromCDB(const FilePath& compil
 	return std::vector<FilePath>();
 }
 
-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::handleMessage(MessageInterruptTasks* message)
-{
-}
-
-void TaskParseCxx::abort()
 {
 }

src/trial/data/parser/cxx/TaskParseWrapper.cpp

@@ -16,40 +16,23 @@ TaskParseWrapper::~TaskParseWrapper()
 {
 }
 
-void TaskParseWrapper::enter()
+void TaskParseWrapper::setTask(std::shared_ptr<Task> 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();
+	return STATE_SUCCESS;
-
-	m_storage->finishParsing();
-
-	MessageFinishedParsing().dispatch();
 }
 
-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();
 }

src/trial/data/parser/java/TaskParseJava.cpp

@@ -1,8 +1,7 @@
 #include "data/parser/java/TaskParseJava.h"
 
 TaskParseJava::TaskParseJava(
-	PersistentStorage* storage,
+	std::shared_ptr<IntermediateStorage> storage,
-	std::shared_ptr<std::mutex> storageMutex,
 	std::shared_ptr<FileRegister> 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::handleMessage(MessageInterruptTasks* message)
-{
-}
-
-void TaskParseJava::abort()
 {
 }