*/
  public static <N> Traverser<N> forGraph(SuccessorsFunction<N> graph) {
    return new Traverser<N>(graph) {
      @Override
      Traversal<N> newTraversal() {
        return Traversal.inGraph(graph);
      }
    };
  }

  /**
   * Creates a new traverser for a directed acyclic graph that has at most one path from the start

   * @since 24.0
   */
  Set<E> incidentEdges(N node);

  /**
   * Returns a live view of all edges in this network which can be traversed in the direction (if
   * any) of the edge to end at {@code node}.
   *
   * <p>In a directed network, an incoming edge's {@link EndpointPair#target()} equals {@code node}.
   *

 *       locks---to each of the acquired locks, an edge from the soon-to-be-acquired lock is either
 *       verified or created.
 *   <li>If a new edge needs to be created, the outgoing edges of the acquired locks are traversed
 *       to check for a cycle that reaches the lock to be acquired. If no cycle is detected, a new
 *       "safe" edge is created.
 *   <li>If a cycle is detected, an "unsafe" (cyclic) edge is created to represent a potential

	    [<a href="#Go_1.27">Go 1.27</a>] for a (possibly promoted) field
	    of the struct; the key selects that field.
	</li>
	<li>The types of the embedded fields (if any) <a href="#Selectors">traversed</a>
	    to reach a selected field must not be pointer types.
	</li>
	<li>A key must not denote a promoted field inside an embedded struct if
	    that struct is also specified by another key.
	</li>

   */
  private static <N> Iterable<N> getReachableNodes(
      Graph<N> graph, N node, TransitiveClosureSelfLoopStrategy strategy) {
    Traverser<N> traverser = Traverser.forGraph(graph);
    switch (strategy) {
      case ADD_SELF_LOOPS_ALWAYS: // always include 'node'
        return traverser.breadthFirst(node);
      case ADD_SELF_LOOPS_FOR_CYCLES: // include 'node' iff there's an incident cycle

    return checkNotNull(iterable);
  }

  /**
   * Returns a fluent iterable that combines two iterables. The returned iterable has an iterator
   * that traverses the elements in {@code a}, followed by the elements in {@code b}. The source
   * iterators are not polled until necessary.
   *
   * <p>The returned iterable's iterator supports {@code remove()} when the corresponding input

    return checkNotNull(iterable);
  }

  /**
   * Returns a fluent iterable that combines two iterables. The returned iterable has an iterator
   * that traverses the elements in {@code a}, followed by the elements in {@code b}. The source
   * iterators are not polled until necessary.
   *
   * <p>The returned iterable's iterator supports {@code remove()} when the corresponding input

 * Collection} and {@link Iterator} interfaces. The Iterator provided in method {@link #iterator()}
 * is not guaranteed to traverse the elements of the MonitorBasedPriorityBlockingQueue in
 * any particular order. If you need ordered traversal, consider using {@code
 * Arrays.sort(pq.toArray())}. Also, method {@code drainTo} can be used to remove some or

    /**
     * Validates that a given path is safe and does not attempt path traversal attacks.
     * <p>
     * This method checks if the resolved absolute path starts with the allowed base directory,
     * preventing access to files outside the intended directory through path traversal
     * techniques like "../../../etc/passwd".
     * </p>
     * <p>
     * Example usage:
     * </p>

   * Returns an iterator over the elements in this queue in proper sequence. The returned {@code
   * Iterator} is a "weakly consistent" iterator that will never throw {@link
   * ConcurrentModificationException}, and guarantees to traverse elements as they existed upon
   * construction of the iterator, and may (but is not guaranteed to) reflect any modifications
   * subsequent to construction.
   *