Method join_all_threads

src/Threads/ThreadManager.h:163–205

* Joins all the threads that have been started so far except the threads * launch with a key in the 'execeptions' vector passed as parameter */

	 * launch with a key in the 'execeptions' vector passed as parameter
	 */
	static void join_all_threads(const std::unordered_set<std::string>& exceptions = {})
	{
		// Joining all the threads and their dependencies
		for (const auto& key_to_threads : m_threads_map)
		{
			std::deque<std::string> dependencies_to_wait_for;
			std::deque<std::string> dependencies_to_analyze;

			const std::string& thread_key = key_to_threads.first;
			if (exceptions.find(thread_key) != exceptions.end())
				// This thread is in the exception list. Not joining these threads
				continue;

			if (!m_dependencies[thread_key].empty())
				for (const std::string& dependency : m_dependencies[thread_key])
					dependencies_to_analyze.push_back(dependency);
			// Pushing the thread key itself we want to wait for and then we'll
			// push its dependencies in front of it so that we wait for the dependencies first
			dependencies_to_wait_for.push_front(thread_key);

			while (!dependencies_to_analyze.empty())
			{
				std::string new_dependency = dependencies_to_analyze.front();
				dependencies_to_analyze.pop_front();
				dependencies_to_wait_for.push_front(new_dependency);

				const std::unordered_set<std::string>& dependencies = m_dependencies[new_dependency];
				for (const std::string& dependency : dependencies)
					dependencies_to_analyze.push_front(dependency);
			}

			std::unordered_set<std::string> dependencies_already_joined;
			for (const std::string& dependency : dependencies_to_wait_for)
			{
				if (dependencies_already_joined.find(dependency) == dependencies_already_joined.end())
				{
					// Dependency not joined yet
					dependencies_already_joined.insert(dependency);
					join_threads(dependency);
				}
			}
		}
	}

	static void detach_threads(const std::string& key)
	{