com.google.common.graph.DirectedGraphConnections java code examples

Common ways to obtain DirectedGraphConnections

private void myMethod () {
 DirectedGraphConnections d =new DirectedGraphConnections<>(new HashMap<N, Object>(capacity, loadFactor), float2, 0)
Map map;Set set;Map map2;new DirectedGraphConnections<>(ImmutableMap.copyOf(map), set.size(), map2.size())
Smart code suggestions by Codota
}

static <N, V> DirectedGraphConnections<N, V> of() {
 // We store predecessors and successors in the same map, so double the initial capacity.
 int initialCapacity = INNER_CAPACITY * 2;
 return new DirectedGraphConnections<>(
   new HashMap<N, Object>(initialCapacity, INNER_LOAD_FACTOR), 0, 0);
}

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

private static <N> GraphConnections<N, Presence> connectionsOf(Graph<N> graph, N node) {
 Function<Object, Presence> edgeValueFn = Functions.constant(Presence.EDGE_EXISTS);
 return graph.isDirected()
   ? DirectedGraphConnections.ofImmutable(
     graph.predecessors(node), Maps.asMap(graph.successors(node), edgeValueFn))
   : UndirectedGraphConnections.ofImmutable(
     Maps.asMap(graph.adjacentNodes(node), edgeValueFn));
}

 private static <N, V> GraphConnections<N, V> connectionsOf(
   final ValueGraph<N, V> graph, final N node) {
  Function<N, V> successorNodeToValueFn =
    new Function<N, V>() {
     @Override
     public V apply(N successorNode) {
      return graph.edgeValueOrDefault(node, successorNode, null);
     }
    };
  return graph.isDirected()
    ? DirectedGraphConnections.ofImmutable(
      graph.predecessors(node), Maps.asMap(graph.successors(node), successorNodeToValueFn))
    : UndirectedGraphConnections.ofImmutable(
      Maps.asMap(graph.adjacentNodes(node), successorNodeToValueFn));
 }
}

 private static <N, V> GraphConnections<N, V> connectionsOf(
   final ValueGraph<N, V> graph, final N node) {
  Function<N, V> successorNodeToValueFn =
    new Function<N, V>() {
     @Override
     public V apply(N successorNode) {
      return graph.edgeValueOrDefault(node, successorNode, null);
     }
    };
  return graph.isDirected()
    ? DirectedGraphConnections.ofImmutable(
      graph.predecessors(node), Maps.asMap(graph.successors(node), successorNodeToValueFn))
    : UndirectedGraphConnections.ofImmutable(
      Maps.asMap(graph.adjacentNodes(node), successorNodeToValueFn));
 }
}

static <N, V> DirectedGraphConnections<N, V> ofImmutable(
  Set<N> predecessors, Map<N, V> successorValues) {
 Map<N, Object> adjacentNodeValues = new HashMap<>();
 adjacentNodeValues.putAll(successorValues);
 for (N predecessor : predecessors) {
  Object value = adjacentNodeValues.put(predecessor, PRED);
  if (value != null) {
   adjacentNodeValues.put(predecessor, new PredAndSucc(value));
  }
 }
 return new DirectedGraphConnections<>(
   ImmutableMap.copyOf(adjacentNodeValues), predecessors.size(), successorValues.size());
}

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

private static <N> GraphConnections<N, Presence> connectionsOf(Graph<N> graph, N node) {
 Function<Object, Presence> edgeValueFn = Functions.constant(Presence.EDGE_EXISTS);
 return graph.isDirected()
   ? DirectedGraphConnections.ofImmutable(
     graph.predecessors(node), Maps.asMap(graph.successors(node), edgeValueFn))
   : UndirectedGraphConnections.ofImmutable(
     Maps.asMap(graph.adjacentNodes(node), edgeValueFn));
}

static <N, V> DirectedGraphConnections<N, V> of() {
 // We store predecessors and successors in the same map, so double the initial capacity.
 int initialCapacity = INNER_CAPACITY * 2;
 return new DirectedGraphConnections<>(
   new HashMap<N, Object>(initialCapacity, INNER_LOAD_FACTOR), 0, 0);
}

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

private static <N> GraphConnections<N, Presence> connectionsOf(Graph<N> graph, N node) {
 Function<Object, Presence> edgeValueFn = Functions.constant(Presence.EDGE_EXISTS);
 return graph.isDirected()
   ? DirectedGraphConnections.ofImmutable(
     graph.predecessors(node), Maps.asMap(graph.successors(node), edgeValueFn))
   : UndirectedGraphConnections.ofImmutable(
     Maps.asMap(graph.adjacentNodes(node), edgeValueFn));
}

static <N, V> DirectedGraphConnections<N, V> of() {
 // We store predecessors and successors in the same map, so double the initial capacity.
 int initialCapacity = INNER_CAPACITY * 2;
 return new DirectedGraphConnections<>(
   new HashMap<N, Object>(initialCapacity, INNER_LOAD_FACTOR), 0, 0);
}

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

 private static <N, V> GraphConnections<N, V> connectionsOf(
   final ValueGraph<N, V> graph, final N node) {
  Function<N, V> successorNodeToValueFn =
    new Function<N, V>() {
     @Override
     public V apply(N successorNode) {
      return graph.edgeValueOrDefault(node, successorNode, null);
     }
    };
  return graph.isDirected()
    ? DirectedGraphConnections.ofImmutable(
      graph.predecessors(node), Maps.asMap(graph.successors(node), successorNodeToValueFn))
    : UndirectedGraphConnections.ofImmutable(
      Maps.asMap(graph.adjacentNodes(node), successorNodeToValueFn));
 }
}

static <N, V> DirectedGraphConnections<N, V> ofImmutable(
  Set<N> predecessors, Map<N, V> successorValues) {
 Map<N, Object> adjacentNodeValues = new HashMap<>();
 adjacentNodeValues.putAll(successorValues);
 for (N predecessor : predecessors) {
  Object value = adjacentNodeValues.put(predecessor, PRED);
  if (value != null) {
   adjacentNodeValues.put(predecessor, new PredAndSucc(value));
  }
 }
 return new DirectedGraphConnections<>(
   ImmutableMap.copyOf(adjacentNodeValues), predecessors.size(), successorValues.size());
}

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

private static <N> GraphConnections<N, Presence> connectionsOf(Graph<N> graph, N node) {
 Function<Object, Presence> edgeValueFn = Functions.constant(Presence.EDGE_EXISTS);
 return graph.isDirected()
   ? DirectedGraphConnections.ofImmutable(
     graph.predecessors(node), Maps.asMap(graph.successors(node), edgeValueFn))
   : UndirectedGraphConnections.ofImmutable(
     Maps.asMap(graph.adjacentNodes(node), edgeValueFn));
}

static <N, V> DirectedGraphConnections<N, V> ofImmutable(
  Set<N> predecessors, Map<N, V> successorValues) {
 Map<N, Object> adjacentNodeValues = new HashMap<>();
 adjacentNodeValues.putAll(successorValues);
 for (N predecessor : predecessors) {
  Object value = adjacentNodeValues.put(predecessor, PRED);
  if (value != null) {
   adjacentNodeValues.put(predecessor, new PredAndSucc(value));
  }
 }
 return new DirectedGraphConnections<>(
   ImmutableMap.copyOf(adjacentNodeValues), predecessors.size(), successorValues.size());
}

private static <N> GraphConnections<N, Presence> connectionsOf(Graph<N> graph, N node) {
 Function<Object, Presence> edgeValueFn = Functions.constant(Presence.EDGE_EXISTS);
 return graph.isDirected()
   ? DirectedGraphConnections.ofImmutable(
     graph.predecessors(node), Maps.asMap(graph.successors(node), edgeValueFn))
   : UndirectedGraphConnections.ofImmutable(
     Maps.asMap(graph.adjacentNodes(node), edgeValueFn));
}

static <N, V> DirectedGraphConnections<N, V> of() {
 // We store predecessors and successors in the same map, so double the initial capacity.
 int initialCapacity = INNER_CAPACITY * 2;
 return new DirectedGraphConnections<>(
   new HashMap<N, Object>(initialCapacity, INNER_LOAD_FACTOR), 0, 0);
}

Javadoc

An implementation of GraphConnections for directed graphs.

Most used methods

Popular in Java

Running tasks concurrently on multiple threads
startActivity (Activity)
getResourceAsStream (ClassLoader)
compareTo (BigDecimal)
Compares this BigDecimal with the specified BigDecimal. Two BigDecimal objects that are equal in val
FileOutputStream (java.io)
A file output stream is an output stream for writing data to aFile or to a FileDescriptor. Whether
Vector (java.util)
The Vector class implements a growable array of objects. Like an array, it contains components that
ConcurrentHashMap (java.util.concurrent)
A hash table supporting full concurrency of retrievals and adjustable expected concurrency for updat
Executors (java.util.concurrent)
Factory and utility methods for Executor, ExecutorService, ScheduledExecutorService, ThreadFactory,
Cipher (javax.crypto)
This class provides access to implementations of cryptographic ciphers for encryption and decryption
JCheckBox (javax.swing)

How to useDirectedGraphConnections in com.google.common.graph

Best Java code snippets using com.google.common.graph.DirectedGraphConnections (Showing top 20 results out of 315)

How to use
DirectedGraphConnections
in
com.google.common.graph