How to use com.google.common.graph

 private NetworkConnections<N, E> newConnections() {
  return isDirected()
    ? allowsParallelEdges()
      ? DirectedMultiNetworkConnections.<N, E>of()
      : DirectedNetworkConnections.<N, E>of()
    : allowsParallelEdges()
      ? UndirectedMultiNetworkConnections.<N, E>of()
      : UndirectedNetworkConnections.<N, E>of();
 }
}

@Override
public EndpointPair<N> incidentNodes(E edge) {
 N nodeU = checkedReferenceNode(edge);
 N nodeV = nodeConnections.get(nodeU).adjacentNode(edge);
 return EndpointPair.of(this, nodeU, nodeV);
}

 private GraphConnections<N, V> newConnections() {
  return isDirected()
    ? DirectedGraphConnections.<N, V>of()
    : UndirectedGraphConnections.<N, V>of();
 }
}

private static MutableGraph<Integer> buildDirectedGraph() {
 MutableGraph<Integer> directedGraph = GraphBuilder.directed().allowsSelfLoops(true).build();
 directedGraph.putEdge(N1, N1);
 directedGraph.putEdge(N1, N2);
 directedGraph.putEdge(N2, N1);
 return directedGraph;
}

private static <N> ImmutableGraph<N> graphWithNode(N node) {
 MutableGraph<N> graph = GraphBuilder.directed().build();
 graph.addNode(node);
 return ImmutableGraph.copyOf(graph);
}

/**
 * Returns a {@link GraphBuilder} initialized with all properties queryable from {@code graph}.
 *
 * <p>The "queryable" properties are those that are exposed through the {@link Graph} interface,
 * such as {@link Graph#isDirected()}. Other properties, such as {@link #expectedNodeCount(int)},
 * are not set in the new builder.
 */
public static <N> GraphBuilder<N> from(Graph<N> graph) {
 return new GraphBuilder<N>(graph.isDirected())
   .allowsSelfLoops(graph.allowsSelfLoops())
   .nodeOrder(graph.nodeOrder());
}

@Override
public EndpointPair<N> incidentNodes(E edge) {
 EndpointPair<N> endpointPair = delegate().incidentNodes(edge);
 return EndpointPair.of(network, endpointPair.nodeV(), endpointPair.nodeU()); // transpose
}

private static MutableGraph<Integer> buildUndirectedGraph() {
 MutableGraph<Integer> undirectedGraph = GraphBuilder.undirected().allowsSelfLoops(true).build();
 undirectedGraph.putEdge(N1, N1);
 undirectedGraph.putEdge(N1, N2);
 undirectedGraph.putEdge(N2, N1);
 return undirectedGraph;
}

protected boolean addEdge(EndpointPair<Integer> endpoints, String e) {
 network.addNode(endpoints.nodeU());
 network.addNode(endpoints.nodeV());
 return network.addEdge(endpoints, e);
}

 private static <N> ImmutableNetwork<N, N> networkWithNode(N node) {
  MutableNetwork<N, N> network = NetworkBuilder.directed().build();
  network.addNode(node);
  return ImmutableNetwork.copyOf(network);
 }
}

 @Override
 public V apply(EndpointPair<N> edge) {
  return graph.edgeValueOrDefault(edge.nodeU(), edge.nodeV(), null);
 }
};

@Override
public Set<E> edgesConnecting(EndpointPair<N> endpoints) {
 validateEndpoints(endpoints);
 return edgesConnecting(endpoints.nodeU(), endpoints.nodeV());
}

private static MutableValueGraph<Integer, String> buildUndirectedValueGraph() {
 MutableValueGraph<Integer, String> undirectedGraph =
   ValueGraphBuilder.undirected().allowsSelfLoops(true).build();
 undirectedGraph.putEdgeValue(N1, N1, E11);
 undirectedGraph.putEdgeValue(N1, N2, E12);
 undirectedGraph.putEdgeValue(N2, N1, E21); // overwrites E12
 return undirectedGraph;
}

@Override
public boolean putEdge(EndpointPair<N> endpoints) {
 validateEndpoints(endpoints);
 return putEdge(endpoints.nodeU(), endpoints.nodeV());
}

 @Override
 public N apply(E edge) {
  return network.incidentNodes(edge).target();
 }
};

 @Override
 public N apply(E edge) {
  return network.incidentNodes(edge).adjacentNode(node);
 }
};

 @Override
 public boolean hasEdgeConnecting(EndpointPair<N> endpoints) {
  return delegate().hasEdgeConnecting(transpose(endpoints));
 }
}

 @Override
 public boolean hasEdgeConnecting(EndpointPair<N> endpoints) {
  return delegate().hasEdgeConnecting(transpose(endpoints));
 }
}

 protected final V edgeValueOrDefault_internal(N nodeU, N nodeV, V defaultValue) {
  GraphConnections<N, V> connectionsU = nodeConnections.get(nodeU);
  V value = (connectionsU == null) ? null : connectionsU.value(nodeV);
  return value == null ? defaultValue : value;
 }
}

private static ImmutableGraph<Character> createSingleRootGraph() {
 MutableGraph<Character> graph = GraphBuilder.directed().build();
 graph.addNode('a');
 return ImmutableGraph.copyOf(graph);
}