Added JavaDoc to the new classes.

import java.util.Objects;

import java.util.Set;

/**

 * This class contains some utility methods related to inspecting nodes and layer structure regarding possible

 * infeasible node arrangements.

 *

 * @author Sebastian Vollbrecht

 */

public class InfeasibilityInspector {

	/**

	 * Computes possible problematic resources whose limit could be exceeded in a cycle, using the provided set of

	 * nodes. The maximum inner delay is taken into account to discard resources whose delay exceeds the maximum inner

	 * delay already. A cycle consisting of these resources would automatically exceed the specified MinII.

	 * delay already. A cycle consisting of these resources would automatically exceed corresponding MinIIs.

	 *

	 * @param nodes         the set of nodes

	 * @param maxInnerDelay the cycle's maximum inner delay

	}

	/**

	 * Computes all destination nodes that could potentially be placed in the specified layer and serve as the

	 * destination node for the backedges of an infeasible cycle. The infeasible cycle's parameters (i.e. problematic

	 * resource, layer structure, node table and the maximum inner delay) are extracted from the provided start

	 * configuration.

	 *

	 * @param dstNodeLayer the layer for which possible possible destination nodes are needed

	 * @param startCfg     the start configuration containing the cycle's parameters

	 * @return a set containing all potential destination node candidates

	 */

	public static Set<ResourceNode> getPossibleDstNodes(int dstNodeLayer, StartConfiguration startCfg) {

		Set<ResourceNode> possibleDstNodes = new HashSet<>();

		 * If the current destination node's delay makes it impossible to ensure the

		 * RecMinII, the delay is not valid.

		 */

		if (dstNodeDelay + problematicResource.delay > startCfg.getMaxInnerDelay())

		if (dstNodeDelay + problematicResource.delay > startCfg.getMaxInnerDelay()) {

			return false;

		}

		/*

		 * If only the problematic nodes have the current delay, we cannot use it if

				 * problematic node if the resource's delay is zero).

				 *

				 * If no additional end node can be used, the maximum inner delay will be

				 * impossible to ensure and the destination node's delay/layer are invalid.

				 * impossible to ensure (as there wouldn't be any edges available to distribute

				 * the remaining delay over) and the destination node's delay/layer are invalid.

				 */

				if (isProblematicDelayZero && isSameDelay && 0 < startCfg.getMaxInnerDelay()) {

					if (lastProblematicLayer < lastPossibleLayer) {

						for (int remainingDelay : remainingDelays.keySet()) {

							if (zeroNodesRemaining == 0 && remainingDelay == 0)

							if (zeroNodesRemaining == 0 && remainingDelay == 0) {

								continue;

							}

							if (remainingDelay <= startCfg.getMaxInnerDelay()) {

								candidateFound = true;

			/*

			 * If there are no nodes left with a delay of zero and if not all problematic

			 * nodes have yet been placed, the delay is impossible: we cannot use the next

			 * layer without increasing its minimal ASAP time.

			 * layer without automatically pushing its nodes in different timeslots.

			 */

			if (zeroNodesRemaining == 0)

			if (zeroNodesRemaining == 0) {

				return false;

			}

			/*

			 * Otherwise, place as many problematic nodes as possible in the current layer.

		Map<Integer, Integer> remainingDelays = new HashMap<>();

		/*

		 * Skip an amount of nodes equal to (the resource's limit + 1) in order to compute the

		 * Skip an amount of nodes equal to [the resource's limit + 1] in order to compute the

		 * remaining delays if the resource were to be deemed the problematic resource.

		 */

		int skipsRequired = Objects.requireNonNull(problematicResource).limit + 1;

package graphgen.generator.components.properties.infeasibleMinII;

import graphgen.datastructures.Pair;

import graphgen.datastructures.SeededRandom;

import graphgen.generator.components.properties.infeasibleMinII.configuration.InfeasibleConfiguration;

import graphgen.generator.components.properties.infeasibleMinII.configuration.StartConfiguration;

import java.util.function.Predicate;

import java.util.stream.IntStream;

/**

 * This class is responsible for planning how an infeasible arrangement of nodes can actually be made infeasible with

 * edges interconnecting them. For example, it provides methods for retrieving possible incoming edges, for distributing

 * certain delays over planned edges, for retrieving necessary outgoing edges, ... In other words, it deals with edge

 * delay-specific calculations.

 *

 * @author Sebastian Vollbrecht

 */

public class InfeasibleEdgePlanner {

	private final StartConfiguration startCfg;

	private final SuffixConfiguration suffixCfg;

	private final SeededRandom rng;

	/**

	 * Creates a new edge planner, based on the provided configurations.

	 *

	 * @param startCfg      the start configuration of the infeasible cycle

	 * @param infeasibleCfg the infeasible configuration of the cycle

	 * @param suffixCfg     the suffix configuration of the cycle

	 * @param rng           the random instance to use to when needed

	 */

	public InfeasibleEdgePlanner(StartConfiguration startCfg, InfeasibleConfiguration infeasibleCfg,

								 SuffixConfiguration suffixCfg, SeededRandom rng) {

		this.startCfg = startCfg;

		this.infeasibleCfg = infeasibleCfg;

		this.suffixCfg = suffixCfg;

		this.rng = rng;

		this.startCfg = Objects.requireNonNull(startCfg);

		this.infeasibleCfg = Objects.requireNonNull(infeasibleCfg);

		this.suffixCfg = Objects.requireNonNull(suffixCfg);

		this.rng = Objects.requireNonNull(rng);

	}

	/**

	 * Computes all timeslots which the problematic nodes could be placed in (relative to the destination node in slot

	 * zero) without exceeding the maximum inner delay of the infeasible cycle.

	 *

	 * @return a set containing all such timeslots

	 */

	public Set<Integer> getProblematicTimeslots() {

		Set<Integer> possibleTimeSlots = new HashSet<>();

		ResourceNode destinationNode = Objects.requireNonNull(startCfg).getDestinationNode();

		ResourceNode destinationNode = startCfg.getDestinationNode();

		if (Objects.requireNonNull(infeasibleCfg).getProblematicNodes().contains(destinationNode)) {

		if (infeasibleCfg.getProblematicNodes().contains(destinationNode)) {

			possibleTimeSlots.add(0);

			return possibleTimeSlots;

		}

		if (Objects.requireNonNull(suffixCfg).getSuffixNodes().isEmpty()) {

		if (suffixCfg.getSuffixNodes().isEmpty()) {

			possibleTimeSlots.add(destinationNode.getDelay() + suffixCfg.getRemainingInnerDelay());

			return possibleTimeSlots;

		} else {

		}

	}

	public Set<PlannedEdge> getIncomingEdges() {

	/**

	 * Computes source-destination node pairs for every destination node which needs an incoming edge. These include

	 * problematic/zero nodes (source nodes can either be the destination node or other zero nodes) and the suffix nodes

	 * (source nodes can either be the lowest problematic nodes or another suffix node).<p>If there is more than valid

	 * predecessor for any of the problematic nodes, the method will choose a valid predecessor using the internal

	 * {@link SeededRandom} instance.

	 *

	 * @return the set of source-destination node pairs representing future edges

	 */

	public Set<Pair<ResourceNode, ResourceNode>> getIncomingEdgePairs() {

		Set<PlannedEdge> edges = new HashSet<>();

		Set<Pair<ResourceNode, ResourceNode>> pairs = new HashSet<>();

		Map<ResourceNode, Set<PlannedEdge>> incomingEdgesByNode = new HashMap<>();

		Map<ResourceNode, Set<PlannedEdge>> outgoingEdgesByNode = new HashMap<>();

		Map<ResourceNode, ResourceNode> predecessorsByNode = new HashMap<>();

		Map<ResourceNode, Set<ResourceNode>> successorsByNode = new HashMap<>();

		/* Generate an incoming edge for every fixed node. */

		/* Pick a predecessor for every fixed node (except for the destination node). */

		for (ResourceNode fixedNode : infeasibleCfg.getFixedNodes()) {

			if (incomingEdgesByNode.containsKey(fixedNode) || fixedNode == startCfg.getDestinationNode()) {

			if (predecessorsByNode.containsKey(fixedNode) || fixedNode == startCfg.getDestinationNode()) {

				continue;

			}

			Set<ResourceNode> predecessors = getPossiblePredecessors(fixedNode, startCfg, infeasibleCfg);

			ResourceNode predecessor = JavaUtils.pickRandomElement(predecessors, rng);

			PlannedEdge edge = new PlannedEdge(predecessor, fixedNode, 0, 0);

			Pair<ResourceNode, ResourceNode> pair = Pair.makePair(predecessor, fixedNode);

			incomingEdgesByNode.putIfAbsent(fixedNode, new HashSet<>());

			incomingEdgesByNode.get(fixedNode).add(edge);

			predecessorsByNode.put(fixedNode, predecessor);

			outgoingEdgesByNode.putIfAbsent(predecessor, new HashSet<>());

			outgoingEdgesByNode.get(predecessor).add(edge);

			successorsByNode.putIfAbsent(predecessor, new HashSet<>());

			successorsByNode.get(predecessor).add(fixedNode);

			edges.add(edge);

			pairs.add(pair);

		}

			if (i == 0) {

				for (ResourceNode src : infeasibleCfg.getLowestProblematicNodes()) {

					PlannedEdge edge = new PlannedEdge(src, suffixNode, 0, 0);

					Pair<ResourceNode, ResourceNode> pair = Pair.makePair(src, suffixNode);

					incomingEdgesByNode.putIfAbsent(src, new HashSet<>());

					incomingEdgesByNode.get(src).add(edge);

					predecessorsByNode.put(suffixNode, src);

					outgoingEdgesByNode.putIfAbsent(src, new HashSet<>());

					outgoingEdgesByNode.get(src).add(edge);

					successorsByNode.putIfAbsent(src, new HashSet<>());

					successorsByNode.get(src).add(suffixNode);

					edges.add(edge);

					pairs.add(pair);

				}

			} else {

				ResourceNode src = suffixCfg.getSuffixNodes().get(i - 1);

				PlannedEdge edge = new PlannedEdge(src, suffixNode, 0, 0);

				Pair<ResourceNode, ResourceNode> pair = Pair.makePair(src, suffixNode);

				incomingEdgesByNode.putIfAbsent(suffixNode, new HashSet<>());

				incomingEdgesByNode.get(suffixNode).add(edge);

				predecessorsByNode.put(suffixNode, src);

				outgoingEdgesByNode.putIfAbsent(src, new HashSet<>());

				outgoingEdgesByNode.get(src).add(edge);

				successorsByNode.putIfAbsent(src, new HashSet<>());

				successorsByNode.get(src).add(suffixNode);

				edges.add(edge);

				pairs.add(pair);

			}

		}

		return edges;

		return pairs;

	}

	}

	/**

	 * Distributes the cycle's remaining inner delay over the provided set of planned edges. This method makes sure that

	 * all problematic nodes are going to be end up in the same, provided timeslot. The set of edges <i>must</i> include

	 * an incoming edge for every problematic node (except for the destination node), for every zero node and for every

	 * suffix node (if present) to ensure the infeasibility. <p>If a suffix has been created, the provided set must

	 * furthermore contain an outgoing edge for the lowest problematic nodes (these edges can easily soak up parts of

	 * the remaining delay). The distribution process makes sure that these lowest edges are going to have the exact

	 * same delay so as not to introduce slack in any of the lowest problematic nodes.

	 *

	 * @param problematicTimeslot the problematic nodes' timeslot, needed to compute slacks and offsets

	 * @param edges               the existing set of planned edges

	 * @return an optional containing the delay of the lowest edges if a suffix has been created, otherwise an empty

	 * optional

	 */

	public Optional<Integer> distributeDelay(int problematicTimeslot, Set<PlannedEdge> edges) {

		if (problematicTimeslot < 0) {

			throw new IllegalArgumentException("The problematic nodes' timeslot cannot be negative.");

		} else if (problematicTimeslot + infeasibleCfg.getProblematicResource().delay > infeasibleCfg

				.getMaxInnerDelay()) {

			throw new IllegalArgumentException(

					"Placing the nodes in the specified timeslot would exceed the maximum inner delay.");

		}

		Map<ResourceNode, PlannedEdge> incomingEdgesByNode = getIncomingEdgesMap(edges, infeasibleCfg.getFixedNodes());

		for (ResourceNode dst : infeasibleCfg.getFixedNodes()) {

			if (dst != startCfg.getDestinationNode() && !incomingEdgesByNode.containsKey(dst)) {

				throw new IllegalArgumentException("Fixed node " + dst + " does not have any incoming edges.");

			}

		}

		/*

		 * The delay we need to distribute over edges leading to the problematic nodes

		 * so that they all end up in the given problematic timeslot.

		 */

		int problematicEdgesDelay = problematicTimeslot - startCfg.getDestinationNode().getDelay();

		/* The set of edges whose delay must not change anymore to not destroy the infeasibility. */

		Set<PlannedEdge> fixedEdges = new HashSet<>();

		/*

		 * Make every problematic node's timeslot problematic (i.e. distribute the

		 * required delay over the edges leading to it). We must sort the nodes by their

		 * depth so that possible problematic zero nodes will be handled before their

		 * successors. Otherwise it might be possible for the summed delay (delay to the

		 * zero node plus the delay to the successor) to exceed the required delay.

		 */

		for (ResourceNode node : JavaUtils.asSortedList(infeasibleCfg.getProblematicNodes(), Comparator

				.comparingInt(n -> infeasibleCfg.getLayers().getDepth(n.getId())))) {

			makeNodeSlotProblematic(node, problematicEdgesDelay, incomingEdgesByNode, fixedEdges);

		}

		List<ResourceNode> suffixNodes = suffixCfg.getSuffixNodes();

		if (!suffixNodes.isEmpty()) {

			/*

			 * Add an edge representing all edges connecting from the lowest problematic nodes

			 * to the first suffix node. These edges MUST have equal delays.

			 */

			Set<ResourceNode> lowestNodes = infeasibleCfg.getLowestProblematicNodes();

			Set<ResourceNode> relevantNodes = new HashSet<>(lowestNodes);

			relevantNodes.addAll(suffixNodes);

			Map<ResourceNode, PlannedEdge> outgoingEdgesByNode = getOutgoingEdgesMap(edges, relevantNodes);

			for (ResourceNode src : relevantNodes) {

				if (!outgoingEdgesByNode.containsKey(src) && src != suffixNodes.get(suffixNodes.size() - 1)) {

					throw new IllegalArgumentException("Node " + src + " does not have any outgoing edge.");

				}

			}

			List<PlannedEdge> suffixChain = new ArrayList<>();

			PlannedEdge representative = outgoingEdgesByNode.get(lowestNodes.iterator().next());

			suffixChain.add(representative);

			suffixChain.addAll(getSuffixEdgeChain(outgoingEdgesByNode));

			int remainingDelay = suffixCfg.getRemainingInnerDelay() - (problematicTimeslot - startCfg

					.getDestinationNode().getDelay());

			PlannedEdge.distributeDelay(suffixChain, remainingDelay, rng);

			for (ResourceNode lowestNode : lowestNodes) {

				outgoingEdgesByNode.get(lowestNode).delay = representative.delay;

			}

			return Optional.of(representative.delay);

		}

		return Optional.empty();

	}

	/**

	 * Computes a set of outgoing edges for the cycle's nodes which would both fulfill the minimally needed edge

	 * requirement that every node needs at least one outgoing edge <i>and</i> which would still guarantee the

	 * infeasibility of the cycle. The calculation takes into account the timeslot the problematic nodes are located in

	 * and the suffix nodes' offsets (relative to the destination node). If any of the problematic/zero/suffix nodes

	 * already has an outgoing edge (as specified by the given predicate), it will be skipped. The provided delay

	 * computer is used to compute possible edge delays, whose validity is then analyzed.<p>More formally, a problematic

	 * node's outgoing edge can either be an edge connecting to other fixed nodes/suffix nodes, or it can be a backedge

	 * connecting to the destination node, thereby reducing the fixed node's slack to zero as well.<p>A problematic node

	 * may however only connect to other problematic nodes if both the edge's delay and the problematic resource's delay

	 * are zero. Otherwise, the target node's ASAP time would increase and it would no longer share the problematic slot

	 * with the other nodes.<p>Furthermore, a problematic node may only connect to suffix nodes if the edge delay of the

	 * resulting edge would reduce the problematic node's slack to zero.<p> If no possible destination node can be found

	 * for any problematic node, it will be connected to the first suffix node (if present) to keep the edge delay

	 * minimal. If no suffix has been created, the node must become a backedge source.

	 *

	 * @param problematicTimeslot   the problematic nodes' timeslot, needed to compute slacks and offsets

	 * @param nodeNeedsOutgoingEdge a predicate specifying which nodes still need an outgoing edge

	 * @param delayComputer         the delay computer to use to compute possible edge delays

	 * @return a set of outgoing edges with their delays set as needed

	 */

	public Set<PlannedEdge> getOutgoingEdges(int problematicTimeslot, Predicate<ResourceNode> nodeNeedsOutgoingEdge,

											 BiFunction<ResourceNode, ResourceNode, Integer> delayComputer) {

		return problematicEdges;

	}

	public Optional<PlannedEdge> distributeDelay(int problematicTimeslot, Set<PlannedEdge> edges) {

		if (problematicTimeslot < 0) {

			throw new IllegalArgumentException("The problematic nodes' timeslot cannot be negative.");

		} else if (problematicTimeslot + infeasibleCfg.getProblematicResource().delay > infeasibleCfg

				.getMaxInnerDelay()) {

			throw new IllegalArgumentException(

					"Placing the nodes in the specified timeslot would exceed the maximum inner delay.");

		}

		Map<ResourceNode, PlannedEdge> incomingEdgesByNode = getIncomingEdgesMap(edges, infeasibleCfg.getFixedNodes());

		for (ResourceNode dst : infeasibleCfg.getFixedNodes()) {

			if (dst != startCfg.getDestinationNode() && !incomingEdgesByNode.containsKey(dst)) {

				throw new IllegalArgumentException("Fixed node " + dst + " does not have any incoming edges.");

			}

		}

		/*

		 * The delay we need to distribute over edges leading to the problematic nodes

		 * so that they all end up in the given problematic timeslot.

		 */

		int problematicEdgesDelay = problematicTimeslot - startCfg.getDestinationNode().getDelay();

		/* The set of edges whose delay must not change anymore to not destroy the infeasibility. */

		Set<PlannedEdge> fixedEdges = new HashSet<>();

		/*

		 * Make every problematic node's timeslot problematic (i.e. distribute the

		 * required delay over the edges leading to it). We must sort the nodes by their

		 * depth so that possible problematic zero nodes will be handled before their

		 * successors. Otherwise it might be possible for the summed delay (delay to the

		 * zero node plus the delay to the successor) to exceed the required delay.

		 */

		for (ResourceNode node : JavaUtils.asSortedList(infeasibleCfg.getProblematicNodes(), Comparator

				.comparingInt(n -> infeasibleCfg.getLayers().getDepth(n.getId())))) {

			makeNodeSlotProblematic(node, problematicEdgesDelay, incomingEdgesByNode, fixedEdges);

		}

		List<ResourceNode> suffixNodes = suffixCfg.getSuffixNodes();

		if (!suffixNodes.isEmpty()) {

			/*

			 * Add an edge representing all edges connecting from the lowest problematic nodes

			 * to the first suffix node. These edges MUST have equal delays.

			 */

			Set<ResourceNode> lowestNodes = infeasibleCfg.getLowestProblematicNodes();

			Set<ResourceNode> relevantNodes = new HashSet<>(lowestNodes);

			relevantNodes.addAll(suffixNodes);

			Map<ResourceNode, PlannedEdge> outgoingEdgesByNode = getOutgoingEdgesMap(edges, relevantNodes);

			for (ResourceNode src : relevantNodes) {

				if (!outgoingEdgesByNode.containsKey(src) && src != suffixNodes.get(suffixNodes.size() - 1)) {

					throw new IllegalArgumentException("Node " + src + " does not have any outgoing edge.");

				}

			}

			List<PlannedEdge> suffixChain = new ArrayList<>();

			PlannedEdge representative = outgoingEdgesByNode.get(lowestNodes.iterator().next());

			suffixChain.add(representative);

			suffixChain.addAll(getSuffixEdgeChain(outgoingEdgesByNode));

			int remainingDelay = suffixCfg.getRemainingInnerDelay() - (problematicTimeslot - startCfg

					.getDestinationNode().getDelay());

			PlannedEdge.distributeDelay(suffixChain, remainingDelay, rng);

			for (ResourceNode lowestNode : lowestNodes) {

				outgoingEdgesByNode.get(lowestNode).delay = representative.delay;

			}

			return Optional.of(representative);

		}

		return Optional.empty();

	}

	private List<PlannedEdge> getSuffixEdgeChain(Map<ResourceNode, PlannedEdge> outgoingEdgesByNode) {

		List<PlannedEdge> chain = new ArrayList<>();

	}

	/**

	 * Maps nodes to their incoming edge, based on the provided set of edges. The set containing the relevant nodes is

	 * used to determine which nodes to include in the returned map.

	 *

	 * @param edges         the set of edges

	 * @param relevantNodes the nodes to consider

	 * @return a mapping of relevant nodes to their incoming edge

	 * @throws IllegalArgumentException if any of the relevant nodes has more than one incoming edge or none at all

	 */

	public static Map<ResourceNode, PlannedEdge> getIncomingEdgesMap(Set<PlannedEdge> edges,

																	 Collection<ResourceNode> relevantNodes) {

		Map<ResourceNode, PlannedEdge> incomingEdgesByNode = new HashMap<>();

		for (PlannedEdge edge : Objects.requireNonNull(edges)) {

			if (relevantNodes.contains(edge.src) && relevantNodes.contains(edge.dst)) {

			if (Objects.requireNonNull(relevantNodes).contains(edge.src) && relevantNodes.contains(edge.dst)) {

				if (incomingEdgesByNode.containsKey(edge.dst)) {

					throw new IllegalArgumentException("Node " + edge.dst + " must have exactly one incoming edge.");

		return incomingEdgesByNode;

	}

	/**

	 * Maps nodes to their outgoing edge, based on the provided set of edges. The set containing the relevant nodes is

	 * used to determine which nodes to include in the returned map.

	 *

	 * @param edges         the set of edges

	 * @param relevantNodes the nodes to consider

	 * @return a mapping of relevant nodes to their outgoing edge

	 * @throws IllegalArgumentException if any of the relevant nodes has more than one outgoing edge or none at all

	 */

	public static Map<ResourceNode, PlannedEdge> getOutgoingEdgesMap(Set<PlannedEdge> edges,

																	 Collection<ResourceNode> relevantNodes) {

		Map<ResourceNode, PlannedEdge> outgoingEdgesByNode = new HashMap<>();

		for (PlannedEdge edge : Objects.requireNonNull(edges)) {

			if (relevantNodes.contains(edge.src) && relevantNodes.contains(edge.dst)) {

			if (Objects.requireNonNull(relevantNodes).contains(edge.src) && relevantNodes.contains(edge.dst)) {

				if (outgoingEdgesByNode.containsKey(edge.src)) {

					throw new IllegalArgumentException("Node " + edge.src + " must have exactly one outgoing edge.");