protected final BufferedReader reader;

    /** The line that has been read */
    protected String line = EMPTY;

    /**
     * Returns an {@link Iterable} that wraps a {@link LineIterator} for use in enhanced for-loops.
     *
     * @param reader
     *            The {@link Reader} to read strings from. Must not be {@literal null}.
     * @return An {@link Iterable} that wraps a {@link LineIterator}.
     */

          + "that allows parallel edges, call allowsParallelEdges(true) on the Builder.";
  static final String SELF_LOOPS_NOT_ALLOWED =
      "Cannot add self-loop edge on node %s, as self-loops are not allowed. To construct a graph "
          + "that allows self-loops, call allowsSelfLoops(true) on the Builder.";
  static final String NOT_AVAILABLE_ON_UNDIRECTED =
      "Cannot call source()/target() on a EndpointPair from an undirected graph. Consider calling "

  /**
   * Returns the count of {@code node}'s incident edges, counting self-loops twice (equivalently,
   * the number of times an edge touches {@code node}).
   *
   * <p>For directed graphs, this is equal to {@code inDegree(node) + outDegree(node)}.
   *
   * <p>For undirected graphs, this is equal to {@code incidentEdges(node).size()} + (number of
   * self-loops incident to {@code node}).
   *

 * with user-defined properties.
 *
 * <p>A {@code ValueGraph} built by this class has the following default properties:
 *
 * <ul>
 *   <li>does not allow self-loops
 *   <li>orders {@link ValueGraph#nodes()} in the order in which the elements were added (insertion
 *       order)
 * </ul>
 *

  @SuppressWarnings("unchecked") // how to explain?
  @Override
  public <S extends T> Ordering<S> reverse() {
    return (Ordering<S>) forwardOrder;
  }

  // Override the min/max methods to "hoist" delegation outside loops

  @Override
  public <E extends T> E min(@ParametricNullness E a, @ParametricNullness E b) {
    return forwardOrder.max(a, b);
  }

  @Override
  public <E extends T> E min(

  }

  @Override
  public <S extends Comparable<?>> Ordering<S> reverse() {
    return Ordering.natural();
  }

  // Override the min/max methods to "hoist" delegation outside loops

  @Override
  public <E extends Comparable<?>> E min(E a, E b) {
    return NaturalOrdering.INSTANCE.max(a, b);
  }

  @Override
  public <E extends Comparable<?>> E min(E a, E b, E c, E... rest) {

 * user-defined properties.
 *
 * <p>A {@code Network} built by this class has the following default properties:
 *
 * <ul>
 *   <li>does not allow parallel edges
 *   <li>does not allow self-loops
 *   <li>orders {@link Network#nodes()} and {@link Network#edges()} in the order in which the
 *       elements were added (insertion order)
 * </ul>
 *

	return dst, nil
}

const (
	// Lock maintenance interval.
	lockMaintenanceInterval = 1 * time.Minute

	// Lock validity duration
	lockValidityDuration = 1 * time.Minute
)

// lockMaintenance loops over all locks and discards locks
// that have not been refreshed for some time.
func lockMaintenance(ctx context.Context) {
	if !globalIsDistErasure {
		return
	}

import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;

/** Tests for a directed {@link StandardMutableNetwork} allowing self-loops. */
@AndroidIncompatible
@RunWith(Parameterized.class)
@NullUnmarked
public class StandardMutableDirectedNetworkTest extends AbstractStandardDirectedNetworkTest {

import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;

/** Tests for a directed {@link StandardMutableNetwork} allowing self-loops. */
@AndroidIncompatible
@RunWith(Parameterized.class)
@NullUnmarked
public class StandardMutableDirectedNetworkTest extends AbstractStandardDirectedNetworkTest {