logic: Fixed bugs in TaskParse scheduling

* Added TaskParse as base for TaskParseCxx and TaskParseJava
* Fixed increment and decrement of indexer_count on blackboard not atomic
* Fixed TaskInjectStorage finished before TaskParse started
* Fixed project not cleared when refreshing on now empty project
* Fixed TaskInjectStorage overheating when nothing to do

src/lib/data/TaskInjectStorage.cpp

@@ -1,5 +1,8 @@
 #include "data/TaskInjectStorage.h"
 
+#include <chrono>
+#include <thread>
+
 #include "data/Storage.h"
 #include "data/StorageProvider.h"
 #include "utility/scheduling/Blackboard.h"
@@ -10,11 +13,26 @@ TaskInjectStorage::TaskInjectStorage(
 )
 	: m_storageProvider(storageProvider)
 	, m_target(target)
+	, m_hasInjected(false)
 {
 }
 
 void TaskInjectStorage::doEnter(std::shared_ptr<Blackboard> blackboard)
 {
+	while (!m_hasInjected)
+	{
+		int indexerCount = 0;
+		if (blackboard->get("indexer_count", indexerCount))
+		{
+			if (indexerCount > 0 || m_storageProvider->getStorageCount() > 0)
+			{
+				break;
+			}
+		}
+
+		const int SLEEP_TIME_MS = 25;
+		std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME_MS));
+	}
 }
 
 Task::TaskState TaskInjectStorage::doUpdate(std::shared_ptr<Blackboard> blackboard)
@@ -25,14 +43,20 @@ Task::TaskState TaskInjectStorage::doUpdate(std::shared_ptr<Blackboard> blackboa
 		if (source)
 		{
 			m_target->inject(source.get());
+			m_hasInjected = true;
 			return STATE_SUCCESS;
 		}
 	}
+	else
+	{
+		const int SLEEP_TIME_MS = 25;
+		std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME_MS));
+	}
 
 	int indexerCount = 0;
 	if (blackboard->get("indexer_count", indexerCount))
 	{
-		if (indexerCount > 0)
+		if (indexerCount > 0 || m_storageProvider->getStorageCount() > 0)
 		{
 			return STATE_SUCCESS;
 		}

src/lib/data/TaskInjectStorage.h

@@ -25,6 +25,8 @@ private:
 
 	std::shared_ptr<StorageProvider> m_storageProvider;
 	std::shared_ptr<Storage> m_target;
+
+	bool m_hasInjected;
 };
 
 #endif // TASK_INJECT_STORAGE_H

src/lib/data/parser/TaskParse.cpp

@@ -0,0 +1,50 @@
+#include "data/parser/TaskParse.h"
+
+#include "utility/scheduling/Blackboard.h"
+
+TaskParse::TaskParse(
+	std::shared_ptr<StorageProvider> storageProvider,
+	std::shared_ptr<FileRegister> fileRegister,
+	const Parser::Arguments& arguments,
+	DialogView* dialogView
+)
+	: m_storageProvider(storageProvider)
+	, m_fileRegister(fileRegister)
+	, m_arguments(arguments)
+	, m_dialogView(dialogView)
+	, m_interrupted(false)
+{
+}
+
+void TaskParse::doEnter(std::shared_ptr<Blackboard> blackboard)
+{
+	std::lock_guard<std::mutex> lock(blackboard->getMutex());
+
+	int indexerCount = 0;
+	if (blackboard->get("indexer_count", indexerCount))
+	{
+		indexerCount++;
+		blackboard->set("indexer_count", indexerCount);
+	}
+}
+
+void TaskParse::doExit(std::shared_ptr<Blackboard> blackboard)
+{
+	std::lock_guard<std::mutex> lock(blackboard->getMutex());
+
+	int indexerCount = 0;
+	if (blackboard->get("indexer_count", indexerCount))
+	{
+		indexerCount--;
+		blackboard->set("indexer_count", indexerCount);
+	}
+}
+
+void TaskParse::doReset(std::shared_ptr<Blackboard> blackboard)
+{
+}
+
+void TaskParse::handleMessage(MessageInterruptTasks* message)
+{
+	m_interrupted = true;
+}

src/lib/data/parser/TaskParse.h

@@ -0,0 +1,42 @@
+#ifndef TASK_PARSE_H
+#define TASK_PARSE_H
+
+#include "data/parser/Parser.h"
+#include "utility/scheduling/Task.h"
+#include "utility/messaging/type/MessageInterruptTasks.h"
+#include "utility/messaging/MessageListener.h"
+
+class CxxParser;
+class DialogView;
+class FileRegister;
+class StorageProvider;
+
+class TaskParse
+	: public Task
+	, public MessageListener<MessageInterruptTasks>
+{
+public:
+	TaskParse(
+		std::shared_ptr<StorageProvider> storageProvider,
+		std::shared_ptr<FileRegister> fileRegister,
+		const Parser::Arguments& arguments,
+		DialogView* dialogView
+	);
+
+protected:
+	virtual void doEnter(std::shared_ptr<Blackboard> blackboard);
+	virtual void doExit(std::shared_ptr<Blackboard> blackboard);
+	virtual void doReset(std::shared_ptr<Blackboard> blackboard);
+
+	virtual void handleMessage(MessageInterruptTasks* message);
+
+	std::shared_ptr<StorageProvider> m_storageProvider;
+	std::shared_ptr<FileRegister> m_fileRegister;
+
+	const Parser::Arguments m_arguments;
+	DialogView* m_dialogView;
+
+	bool m_interrupted;
+};
+
+#endif // TASK_PARSE_H