How to use

ConfigurableMutableValueGraph

in

com.google.common.graph

/**
 * Returns an empty {@link MutableValueGraph} with the properties of this {@link
 * ValueGraphBuilder}.
 */
public <N1 extends N, V1 extends V> MutableValueGraph<N1, V1> build() {
 return new ConfigurableMutableValueGraph<>(this);
}

@Override
@CanIgnoreReturnValue
public boolean addNode(N node) {
 checkNotNull(node, "node");
 if (containsNode(node)) {
  return false;
 }
 addNodeInternal(node);
 return true;
}

@Override
@CanIgnoreReturnValue
public V putEdgeValue(N nodeU, N nodeV, V value) {
 checkNotNull(nodeU, "nodeU");
 checkNotNull(nodeV, "nodeV");
 checkNotNull(value, "value");
 if (!allowsSelfLoops()) {
  checkArgument(!nodeU.equals(nodeV), SELF_LOOPS_NOT_ALLOWED, nodeU);
 }
 GraphConnections<N, V> connectionsU = nodeConnections.get(nodeU);
 if (connectionsU == null) {
  connectionsU = addNodeInternal(nodeU);
 }
 V previousValue = connectionsU.addSuccessor(nodeV, value);
 GraphConnections<N, V> connectionsV = nodeConnections.get(nodeV);
 if (connectionsV == null) {
  connectionsV = addNodeInternal(nodeV);
 }
 connectionsV.addPredecessor(nodeU, value);
 if (previousValue == null) {
  checkPositive(++edgeCount);
 }
 return previousValue;
}

@Override
@CanIgnoreReturnValue
public boolean removeNode(N node) {
 checkNotNull(node, "node");
 GraphConnections<N, V> connections = nodeConnections.get(node);
 if (connections == null) {
  return false;
 }
 if (allowsSelfLoops()) {
  // Remove self-loop (if any) first, so we don't get CME while removing incident edges.
  if (connections.removeSuccessor(node) != null) {
   connections.removePredecessor(node);
   --edgeCount;
  }
 }
 for (N successor : connections.successors()) {
  nodeConnections.getWithoutCaching(successor).removePredecessor(node);
  --edgeCount;
 }
 if (isDirected()) { // In undirected graphs, the successor and predecessor sets are equal.
  for (N predecessor : connections.predecessors()) {
   checkState(nodeConnections.getWithoutCaching(predecessor).removeSuccessor(node) != null);
   --edgeCount;
  }
 }
 nodeConnections.remove(node);
 checkNonNegative(edgeCount);
 return true;
}

/**
 * Adds {@code node} to the graph and returns the associated {@link GraphConnections}.
 *
 * @throws IllegalStateException if {@code node} is already present
 */
@CanIgnoreReturnValue
private GraphConnections<N, V> addNodeInternal(N node) {
 GraphConnections<N, V> connections = newConnections();
 checkState(nodeConnections.put(node, connections) == null);
 return connections;
}

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

@Override
@CanIgnoreReturnValue
public boolean removeNode(N node) {
 checkNotNull(node, "node");
 GraphConnections<N, V> connections = nodeConnections.get(node);
 if (connections == null) {
  return false;
 }
 if (allowsSelfLoops()) {
  // Remove self-loop (if any) first, so we don't get CME while removing incident edges.
  if (connections.removeSuccessor(node) != null) {
   connections.removePredecessor(node);
   --edgeCount;
  }
 }
 for (N successor : connections.successors()) {
  nodeConnections.getWithoutCaching(successor).removePredecessor(node);
  --edgeCount;
 }
 if (isDirected()) { // In undirected graphs, the successor and predecessor sets are equal.
  for (N predecessor : connections.predecessors()) {
   checkState(nodeConnections.getWithoutCaching(predecessor).removeSuccessor(node) != null);
   --edgeCount;
  }
 }
 nodeConnections.remove(node);
 checkNonNegative(edgeCount);
 return true;
}

/**
 * Adds {@code node} to the graph and returns the associated {@link GraphConnections}.
 *
 * @throws IllegalStateException if {@code node} is already present
 */
@CanIgnoreReturnValue
private GraphConnections<N, V> addNodeInternal(N node) {
 GraphConnections<N, V> connections = newConnections();
 checkState(nodeConnections.put(node, connections) == null);
 return connections;
}

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

@Override
@CanIgnoreReturnValue
public boolean addNode(N node) {
 checkNotNull(node, "node");
 if (containsNode(node)) {
  return false;
 }
 addNodeInternal(node);
 return true;
}

@Override
@CanIgnoreReturnValue
public V putEdgeValue(N nodeU, N nodeV, V value) {
 checkNotNull(nodeU, "nodeU");
 checkNotNull(nodeV, "nodeV");
 checkNotNull(value, "value");
 if (!allowsSelfLoops()) {
  checkArgument(!nodeU.equals(nodeV), SELF_LOOPS_NOT_ALLOWED, nodeU);
 }
 GraphConnections<N, V> connectionsU = nodeConnections.get(nodeU);
 if (connectionsU == null) {
  connectionsU = addNodeInternal(nodeU);
 }
 V previousValue = connectionsU.addSuccessor(nodeV, value);
 GraphConnections<N, V> connectionsV = nodeConnections.get(nodeV);
 if (connectionsV == null) {
  connectionsV = addNodeInternal(nodeV);
 }
 connectionsV.addPredecessor(nodeU, value);
 if (previousValue == null) {
  checkPositive(++edgeCount);
 }
 return previousValue;
}

@Override
@CanIgnoreReturnValue
public boolean removeNode(N node) {
 checkNotNull(node, "node");
 GraphConnections<N, V> connections = nodeConnections.get(node);
 if (connections == null) {
  return false;
 }
 if (allowsSelfLoops()) {
  // Remove self-loop (if any) first, so we don't get CME while removing incident edges.
  if (connections.removeSuccessor(node) != null) {
   connections.removePredecessor(node);
   --edgeCount;
  }
 }
 for (N successor : connections.successors()) {
  nodeConnections.getWithoutCaching(successor).removePredecessor(node);
  --edgeCount;
 }
 if (isDirected()) { // In undirected graphs, the successor and predecessor sets are equal.
  for (N predecessor : connections.predecessors()) {
   checkState(nodeConnections.getWithoutCaching(predecessor).removeSuccessor(node) != null);
   --edgeCount;
  }
 }
 nodeConnections.remove(node);
 checkNonNegative(edgeCount);
 return true;
}

/** Constructs a {@link MutableGraph} with the properties specified in {@code builder}. */
ConfigurableMutableGraph(AbstractGraphBuilder<? super N> builder) {
 this.backingValueGraph = new ConfigurableMutableValueGraph<>(builder);
}

/**
 * Adds {@code node} to the graph and returns the associated {@link GraphConnections}.
 *
 * @throws IllegalStateException if {@code node} is already present
 */
@CanIgnoreReturnValue
private GraphConnections<N, V> addNodeInternal(N node) {
 GraphConnections<N, V> connections = newConnections();
 checkState(nodeConnections.put(node, connections) == null);
 return connections;
}

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

@Override
@CanIgnoreReturnValue
public boolean addNode(N node) {
 checkNotNull(node, "node");
 if (containsNode(node)) {
  return false;
 }
 addNodeInternal(node);
 return true;
}

@Override
@CanIgnoreReturnValue
public V putEdgeValue(N nodeU, N nodeV, V value) {
 checkNotNull(nodeU, "nodeU");
 checkNotNull(nodeV, "nodeV");
 checkNotNull(value, "value");
 if (!allowsSelfLoops()) {
  checkArgument(!nodeU.equals(nodeV), SELF_LOOPS_NOT_ALLOWED, nodeU);
 }
 GraphConnections<N, V> connectionsU = nodeConnections.get(nodeU);
 if (connectionsU == null) {
  connectionsU = addNodeInternal(nodeU);
 }
 V previousValue = connectionsU.addSuccessor(nodeV, value);
 GraphConnections<N, V> connectionsV = nodeConnections.get(nodeV);
 if (connectionsV == null) {
  connectionsV = addNodeInternal(nodeV);
 }
 connectionsV.addPredecessor(nodeU, value);
 if (previousValue == null) {
  checkPositive(++edgeCount);
 }
 return previousValue;
}

@Override
@CanIgnoreReturnValue
public boolean removeNode(N node) {
 checkNotNull(node, "node");
 GraphConnections<N, V> connections = nodeConnections.get(node);
 if (connections == null) {
  return false;
 }
 if (allowsSelfLoops()) {
  // Remove self-loop (if any) first, so we don't get CME while removing incident edges.
  if (connections.removeSuccessor(node) != null) {
   connections.removePredecessor(node);
   --edgeCount;
  }
 }
 for (N successor : connections.successors()) {
  nodeConnections.getWithoutCaching(successor).removePredecessor(node);
  --edgeCount;
 }
 if (isDirected()) { // In undirected graphs, the successor and predecessor sets are equal.
  for (N predecessor : connections.predecessors()) {
   checkState(nodeConnections.getWithoutCaching(predecessor).removeSuccessor(node) != null);
   --edgeCount;
  }
 }
 nodeConnections.remove(node);
 checkNonNegative(edgeCount);
 return true;
}

/**
 * Returns an empty {@link MutableValueGraph} with the properties of this {@link
 * ValueGraphBuilder}.
 */
public <N1 extends N, V1 extends V> MutableValueGraph<N1, V1> build() {
 return new ConfigurableMutableValueGraph<>(this);
}

/**
 * Adds {@code node} to the graph and returns the associated {@link GraphConnections}.
 *
 * @throws IllegalStateException if {@code node} is already present
 */
@CanIgnoreReturnValue
private GraphConnections<N, V> addNodeInternal(N node) {
 GraphConnections<N, V> connections = newConnections();
 checkState(nodeConnections.put(node, connections) == null);
 return connections;
}