logic: made parsing interruptable by introducing TaskScheduler

This change introduces the TaskScheduler, which queues and processes Tasks on a separate thread. The Task class provides
a common interface for deriving all specific tasks. A task can split it's processing into multiple update calls. The
TaskScheduler will update a task until it is finished or interrupt it when necessary. TaskGroups can be used to bundle
multiple Tasks together. So far only TaskGroupSequential was implemented which runs the Tasks in the set order.

TaskParseCxx utilizes the CxxParser to parse each source file in a single update call. Parsing can be interrupted using
the ESC key. The Statusbar shows the parsing progress.

src/lib/utility/file/FileRegister.cpp

@@ -3,14 +3,26 @@
 #include "utility/file/FileManager.h"
 #include "utility/file/FileSystem.h"
 
-FileRegister::FileRegister(const FileManager* fileManager, const std::vector<FilePath>& filePaths)
+FileRegister::FileRegister(const FileManager* fileManager)
 	: m_fileManager(fileManager)
 {
+}
+
+const FileManager* FileRegister::getFileManager() const
+{
+	return m_fileManager;
+}
+
+void FileRegister::setFilePaths(const std::vector<FilePath>& filePaths)
+{
+	m_sourceFilePaths.clear();
+	m_includeFilePaths.clear();
+
 	for (const FilePath& path : filePaths)
 	{
 		if (m_fileManager->hasSourceExtension(path))
 		{
-			m_sourceFilePaths.push_back(path);
+			m_sourceFilePaths.emplace(path, STATE_UNPARSED);
 		}
 		else
 		{
@@ -19,29 +31,14 @@ FileRegister::FileRegister(const FileManager* fileManager, const std::vector<Fil
 	}
 }
 
-const FileManager* FileRegister::getFileManager() const
+std::vector<FilePath> FileRegister::getUnparsedSourceFilePaths() const
 {
-	return m_fileManager;
-}
-
-const std::vector<FilePath>& FileRegister::getSourceFilePaths() const
-{
-	return m_sourceFilePaths;
+	return getUnparsedFilePaths(m_sourceFilePaths);
 }
 
 std::vector<FilePath> FileRegister::getUnparsedIncludeFilePaths() const
 {
-	std::vector<FilePath> filePaths;
-
-	for (std::pair<FilePath, ParseState>&& p : m_includeFilePaths)
-	{
-		if (p.second == STATE_UNPARSED)
-		{
-			filePaths.push_back(p.first);
-		}
-	}
-
-	return filePaths;
+	return getUnparsedFilePaths(m_includeFilePaths);
 }
 
 bool FileRegister::includeFileIsParsing(const FilePath& filePath) const
@@ -66,6 +63,17 @@ bool FileRegister::includeFileIsParsed(const FilePath& filePath) const
 	return it->second == STATE_PARSED;
 }
 
+void FileRegister::markSourceFileParsed(const std::string& filePath)
+{
+	std::map<FilePath, ParseState>::iterator it = m_sourceFilePaths.find(FilePath(filePath));
+	if (it == m_sourceFilePaths.end())
+	{
+		return;
+	}
+
+	it->second = STATE_PARSED;
+}
+
 void FileRegister::markIncludeFileParsing(const std::string& filePath)
 {
 	std::map<FilePath, ParseState>::iterator it = m_includeFilePaths.find(FilePath(filePath));
@@ -90,3 +98,28 @@ void FileRegister::markParsingIncludeFilesParsed()
 		}
 	}
 }
+
+std::vector<FilePath> FileRegister::getUnparsedFilePaths(const std::map<FilePath, ParseState> filePaths) const
+{
+	std::vector<FilePath> files;
+
+	for (std::pair<FilePath, ParseState>&& p : filePaths)
+	{
+		if (p.second == STATE_UNPARSED)
+		{
+			files.push_back(p.first);
+		}
+	}
+
+	return files;
+}
+
+size_t FileRegister::getFilesCount() const
+{
+	return m_sourceFilePaths.size() + m_includeFilePaths.size();
+}
+
+size_t FileRegister::getParsedFilesCount() const
+{
+	return getFilesCount() - getUnparsedSourceFilePaths().size() - getUnparsedIncludeFilePaths().size();
+}