persolijn

TargetIterable.java (8612B)

---

 package osm.planner;
 
 import java.util.List;
 import java.util.AbstractSet;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Map;
 import java.util.Objects;
 import java.util.function.Function;
 import java.util.function.Supplier;
 
 /**
  * An iterable representing a set of target entries, each associated with a
  * visitation state.
  *
  * @param <P> The type of target points.
  * @param <T> The type of elements in the iterable.
  */
 public class TargetIterable<P, T> implements Iterable<TargetIterable.TargetSet<P, T>> {
 
     /**
      * Enumeration representing the visitation states of target points in the
      * {@link TargetIterable}.
      */
     public static enum Visited {
         /**
          * Represents a target point that has finished processing.
          */
         FINISHED(false, null),
 
         /**
          * Represents a target point that is currently being processed.
          */
         BUSY(true, FINISHED),
 
         /**
          * Represents a target point that is pending processing.
          */
         PENDING(true, BUSY);
 
         private final boolean include;
         private final Visited next;
 
         /**
          * Constructs a Visited enum with the specified inclusion flag and the next
          * visitation state.
          *
          * @param include The flag indicating whether the target point should be
          *                included in processing.
          * @param next    The next visitation state after this one.
          */
         private Visited(boolean include, Visited next) {
             this.include = include;
             this.next = next;
         }
 
         /**
          * Gets the next visitation state after this one.
          *
          * @return The next visitation state.
          */
         public Visited getNext() {
             return next;
         }
 
         /**
          * Checks if the target point should be included in processing.
          *
          * @return {@code true} if the target point should be included, {@code false}
          *         otherwise.
          */
         public boolean doInclude() {
             return include;
         }
     }
 
     /**
      * Represents a set of target entries associated with their visitation states.
      *
      * @param <P> The type of target points.
      * @param <T> The type of elements in the set.
      */
     public static class TargetSet<P, T> extends AbstractSet<T> {
 
         /**
          * The iterable to which this set belongs.
          */
         public final TargetIterable<P, T> iterable;
 
         /**
          * A map associating each target point with its visitation state.
          */
         public final Map<P, Visited> targetMap;
 
         /**
          * The list of target elements in this set.
          */
         public final List<T> targets;
 
         /**
          * Constructs a TargetSet with the specified iterable, target map, and target
          * elements.
          *
          * @param iterable  The iterable to which this set belongs.
          * @param targetMap A map associating each target point with its visitation
          *                  state.
          * @param targets   The list of target elements in this set.
          */
         private TargetSet(TargetIterable<P, T> iterable, Map<P, Visited> targetMap, List<T> targets) {
             this.iterable = iterable;
             this.targetMap = targetMap;
             this.targets = targets;
         }
 
         /**
          * Returns a string representation of this TargetSet.
          *
          * @return A string representation of this TargetSet.
          */
         @Override
         public String toString() {
             return String.format("TargetSet(%s)", targets);
         }
 
         /**
          * Returns the number of elements in this set.
          *
          * @return The number of elements in this set.
          */
         @Override
         public int size() {
             return targets.size();
         }
 
         /**
          * Returns an iterator over the elements in this set.
          *
          * @return An iterator over the elements in this set.
          */
         @Override
         public Iterator<T> iterator() {
             return targets.iterator();
         }
 
         /**
          * Creates a new iterable to continue processing with additional targets.
          *
          * @param supplier A supplier providing the next element.
          * @return An iterable with additional targets.
          */
         public Iterable<TargetSet<P, T>> doContinue(Supplier<T> supplier) {
             return new TargetIterable<>(iterable.garage, iterable.targetList, targetMap,
                     supplier, iterable.startPoint, iterable.targetPoint);
         }
     }
 
     private final T garage;
     private final Collection<P> targetList;
     private final Supplier<T> supplier;
     private final Function<P, T> startPoint;
     private final Function<P, T> targetPoint;
     private final Map<P, Visited> originalMap;
 
     /**
      * Constructs a TargetIterable.
      *
      * @param garage      The garage element.
      * @param targetList  The list of target points.
      * @param targetMap   A map associating each target point with its visitation
      *                    state.
      * @param supplier    A supplier providing the next element.
      * @param startPoint  A function providing the starting point for a target.
      * @param targetPoint A function providing the target point for a target.
      */
     public TargetIterable(T garage, Collection<P> targetList, Map<P, Visited> targetMap,
             Supplier<T> supplier, Function<P, T> startPoint, Function<P, T> targetPoint) {
         this.garage = garage;
         this.targetList = targetList;
         this.supplier = supplier;
         this.startPoint = startPoint;
         this.targetPoint = targetPoint;
         this.originalMap = targetMap;
     }
 
     /**
      * Constructs a TargetIterable with an empty target map.
      *
      * @param garage      The garage element.
      * @param targetList  The list of target points.
      * @param supplier    A supplier providing the next element.
      * @param startPoint  A function providing the starting point for a target.
      * @param targetPoint A function providing the target point for a target.
      */
     public TargetIterable(T garage, Collection<P> targetList,
             Supplier<T> supplier, Function<P, T> startPoint, Function<P, T> targetPoint) {
         this.garage = garage;
         this.targetList = targetList;
         this.supplier = supplier;
         this.startPoint = startPoint;
         this.targetPoint = targetPoint;
         this.originalMap = Map.of();
     }
 
     @Override
     public Iterator<TargetSet<P, T>> iterator() {
         return new Iterator<TargetIterable.TargetSet<P, T>>() {
             final Map<P, Visited> targetMap = new HashMap<>(TargetIterable.this.originalMap);
 
             private Visited checkVisited(P p, T current) {
                 Visited visited = targetMap.getOrDefault(p, Visited.PENDING);
 
                 if (startPoint.apply(p).equals(current) && visited == Visited.PENDING)
                     visited = visited.getNext();
 
                 if (targetPoint.apply(p).equals(current) && visited == Visited.BUSY)
                     visited = visited.getNext();
 
                 return visited;
             }
 
             @Override
             public boolean hasNext() {
                 T current = supplier.get();
 
                 return current != garage || targetList.stream()
                         .map(p -> checkVisited(p, current))
                         .anyMatch(Visited::doInclude);
             }
 
             @Override
             public TargetSet<P, T> next() {
                 T current = supplier.get();
 
                 List<T> targetNodes = targetList.stream()
                         .map(p -> Map.entry(p, checkVisited(p, current)))
                         .peek(e -> targetMap.put(e.getKey(), e.getValue()))
 
                         .map(e -> switch (e.getValue()) {
                             case PENDING -> startPoint.apply(e.getKey());
                             case BUSY -> targetPoint.apply(e.getKey());
                             case FINISHED -> null;
                         })
                         .filter(Objects::nonNull)
                         .toList();
 
                 if (targetNodes.isEmpty() && current != garage)
                     return new TargetSet<>(TargetIterable.this, targetMap, List.of(garage));
 
                 return new TargetSet<>(TargetIterable.this, targetMap, targetNodes);
             }
         };
     }
 }