Stop task with the given task tag. If task already stopped, then nothing happens.

		:param task_tag: task to stop
		:param stop_dependent: if True, then every task, that require the given task as dependency, will be \
		stopped before.
		:param stop_requirements: if True, then every task, that is required as dependency for the given task, \
		will be stopped after.
		:return: None

def stop_task(self, task_tag, stop_dependent=True, stop_requirements=False):
		""" Stop task with the given task tag. If task already stopped, then nothing happens.

		:param task_tag: task to stop
		:param stop_dependent: if True, then every task, that require the given task as dependency, will be \
		stopped before.
		:param stop_requirements: if True, then every task, that is required as dependency for the given task, \
		will be stopped after.
		:return: None
		"""
		# TODO: "coverage" requires more tests

		task = self.started_tasks(task_registry_id=task_tag)

		if task is None:
			return

		def stop(task_to_stop):
			if task_to_stop in self.__started:
				if isinstance(task_to_stop, WStoppableTask) is True:
					task_to_stop.stop()
				self.__started.remove(task_to_stop)

		def stop_dependency(task_to_stop):
			deeper_dependencies = []
			for dependent_task in self.__started:
				if task_to_stop.__registry_tag__ in dependent_task.__class__.__dependency__:
					deeper_dependencies.append(dependent_task)

			for dependent_task in deeper_dependencies:
				stop_dependency(dependent_task)

			stop(task_to_stop)

		def calculate_requirements(task_to_stop, cross_requirements=False):
			requirements = set()

			for dependent_task in self.__started:
				if dependent_task.__class__.__registry_tag__ in task_to_stop.__class__.__dependency__:
					requirements.add(dependent_task)

			if cross_requirements is True:
				return requirements

			result = set()
			for task_a in requirements:
				requirement_match = False
				for task_b in requirements:
					if task_a.__class__.__registry_tag__ in task_b.__class__.__dependency__:
						requirement_match = True
						break
				if requirement_match is False:
					result.add(task_a)
			return result

		def calculate_priorities(task_to_stop, *extra_tasks, current_result=None, requirements_left=None):
			if current_result is None:
				current_result = []

			tasks_to_stop = [task_to_stop]
			if len(extra_tasks) > 0:
				tasks_to_stop.extend(extra_tasks)

			current_result.append(list(tasks_to_stop))

			all_requirements = calculate_requirements(tasks_to_stop[0], cross_requirements=True)
			nested_requirements = calculate_requirements(tasks_to_stop[0])

			for dependent_task in tasks_to_stop[1:]:
				nested_requirements = nested_requirements.union(calculate_requirements(dependent_task))
				all_requirements.update(calculate_requirements(dependent_task, cross_requirements=True))

			all_requirements = all_requirements.difference(nested_requirements)

			if requirements_left is not None:
				requirements_left = requirements_left.difference(all_requirements)
				nested_requirements.update(requirements_left)

			if len(nested_requirements) == 0:
				return current_result

			return calculate_priorities(
				*list(nested_requirements), current_result=current_result, requirements_left=all_requirements
			)

		if stop_dependent is True:
			stop_dependency(task)

		if stop_requirements is True:
			for task_list in calculate_priorities(task):
				for single_task in task_list:
					stop(single_task)

		if stop_dependent is not True:  # check if we've already stopped this task
			stop(task)