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

Common ways to obtain DirectedNetworkConnections

private void myMethod () {
 DirectedNetworkConnections d =new DirectedNetworkConnections<>(HashBiMap.<E, N>create(int2), HashBiMap.<E, N>create(expectedSize), int1)
Map map;new DirectedNetworkConnections<>(ImmutableBiMap.copyOf(map), ImmutableBiMap.copyOf(map), selfLoopCount)
Smart code suggestions by Tabnine
}

static <N, E> DirectedNetworkConnections<N, E> of() {
 return new DirectedNetworkConnections<>(
   HashBiMap.<E, N>create(EXPECTED_DEGREE), HashBiMap.<E, N>create(EXPECTED_DEGREE), 0);
}

 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();
 }
}

private static <N, E> NetworkConnections<N, E> connectionsOf(Network<N, E> network, N node) {
 if (network.isDirected()) {
  Map<E, N> inEdgeMap = Maps.asMap(network.inEdges(node), sourceNodeFn(network));
  Map<E, N> outEdgeMap = Maps.asMap(network.outEdges(node), targetNodeFn(network));
  int selfLoopCount = network.edgesConnecting(node, node).size();
  return network.allowsParallelEdges()
    ? DirectedMultiNetworkConnections.ofImmutable(inEdgeMap, outEdgeMap, selfLoopCount)
    : DirectedNetworkConnections.ofImmutable(inEdgeMap, outEdgeMap, selfLoopCount);
 } else {
  Map<E, N> incidentEdgeMap =
    Maps.asMap(network.incidentEdges(node), adjacentNodeFn(network, node));
  return network.allowsParallelEdges()
    ? UndirectedMultiNetworkConnections.ofImmutable(incidentEdgeMap)
    : UndirectedNetworkConnections.ofImmutable(incidentEdgeMap);
 }
}

private static <N, E> NetworkConnections<N, E> connectionsOf(Network<N, E> network, N node) {
 if (network.isDirected()) {
  Map<E, N> inEdgeMap = Maps.asMap(network.inEdges(node), sourceNodeFn(network));
  Map<E, N> outEdgeMap = Maps.asMap(network.outEdges(node), targetNodeFn(network));
  int selfLoopCount = network.edgesConnecting(node, node).size();
  return network.allowsParallelEdges()
    ? DirectedMultiNetworkConnections.ofImmutable(inEdgeMap, outEdgeMap, selfLoopCount)
    : DirectedNetworkConnections.ofImmutable(inEdgeMap, outEdgeMap, selfLoopCount);
 } else {
  Map<E, N> incidentEdgeMap =
    Maps.asMap(network.incidentEdges(node), adjacentNodeFn(network, node));
  return network.allowsParallelEdges()
    ? UndirectedMultiNetworkConnections.ofImmutable(incidentEdgeMap)
    : UndirectedNetworkConnections.ofImmutable(incidentEdgeMap);
 }
}

static <N, E> DirectedNetworkConnections<N, E> of() {
 return new DirectedNetworkConnections<>(
   HashBiMap.<E, N>create(EXPECTED_DEGREE), HashBiMap.<E, N>create(EXPECTED_DEGREE), 0);
}

 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();
 }
}

private static <N, E> NetworkConnections<N, E> connectionsOf(Network<N, E> network, N node) {
 if (network.isDirected()) {
  Map<E, N> inEdgeMap = Maps.asMap(network.inEdges(node), sourceNodeFn(network));
  Map<E, N> outEdgeMap = Maps.asMap(network.outEdges(node), targetNodeFn(network));
  int selfLoopCount = network.edgesConnecting(node, node).size();
  return network.allowsParallelEdges()
    ? DirectedMultiNetworkConnections.ofImmutable(inEdgeMap, outEdgeMap, selfLoopCount)
    : DirectedNetworkConnections.ofImmutable(inEdgeMap, outEdgeMap, selfLoopCount);
 } else {
  Map<E, N> incidentEdgeMap =
    Maps.asMap(network.incidentEdges(node), adjacentNodeFn(network, node));
  return network.allowsParallelEdges()
    ? UndirectedMultiNetworkConnections.ofImmutable(incidentEdgeMap)
    : UndirectedNetworkConnections.ofImmutable(incidentEdgeMap);
 }
}

static <N, E> DirectedNetworkConnections<N, E> of() {
 return new DirectedNetworkConnections<>(
   HashBiMap.<E, N>create(EXPECTED_DEGREE), HashBiMap.<E, N>create(EXPECTED_DEGREE), 0);
}

 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();
 }
}

private static <N, E> NetworkConnections<N, E> connectionsOf(Network<N, E> network, N node) {
 if (network.isDirected()) {
  Map<E, N> inEdgeMap = Maps.asMap(network.inEdges(node), sourceNodeFn(network));
  Map<E, N> outEdgeMap = Maps.asMap(network.outEdges(node), targetNodeFn(network));
  int selfLoopCount = network.edgesConnecting(node, node).size();
  return network.allowsParallelEdges()
    ? DirectedMultiNetworkConnections.ofImmutable(inEdgeMap, outEdgeMap, selfLoopCount)
    : DirectedNetworkConnections.ofImmutable(inEdgeMap, outEdgeMap, selfLoopCount);
 } else {
  Map<E, N> incidentEdgeMap =
    Maps.asMap(network.incidentEdges(node), adjacentNodeFn(network, node));
  return network.allowsParallelEdges()
    ? UndirectedMultiNetworkConnections.ofImmutable(incidentEdgeMap)
    : UndirectedNetworkConnections.ofImmutable(incidentEdgeMap);
 }
}

static <N, E> DirectedNetworkConnections<N, E> ofImmutable(
  Map<E, N> inEdges, Map<E, N> outEdges, int selfLoopCount) {
 return new DirectedNetworkConnections<>(
   ImmutableBiMap.copyOf(inEdges), ImmutableBiMap.copyOf(outEdges), selfLoopCount);
}

 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();
 }
}

private static <N, E> NetworkConnections<N, E> connectionsOf(Network<N, E> network, N node) {
 if (network.isDirected()) {
  Map<E, N> inEdgeMap = Maps.asMap(network.inEdges(node), sourceNodeFn(network));
  Map<E, N> outEdgeMap = Maps.asMap(network.outEdges(node), targetNodeFn(network));
  int selfLoopCount = network.edgesConnecting(node, node).size();
  return network.allowsParallelEdges()
    ? DirectedMultiNetworkConnections.ofImmutable(inEdgeMap, outEdgeMap, selfLoopCount)
    : DirectedNetworkConnections.ofImmutable(inEdgeMap, outEdgeMap, selfLoopCount);
 } else {
  Map<E, N> incidentEdgeMap =
    Maps.asMap(network.incidentEdges(node), adjacentNodeFn(network, node));
  return network.allowsParallelEdges()
    ? UndirectedMultiNetworkConnections.ofImmutable(incidentEdgeMap)
    : UndirectedNetworkConnections.ofImmutable(incidentEdgeMap);
 }
}

static <N, E> DirectedNetworkConnections<N, E> ofImmutable(
  Map<E, N> inEdges, Map<E, N> outEdges, int selfLoopCount) {
 return new DirectedNetworkConnections<>(
   ImmutableBiMap.copyOf(inEdges), ImmutableBiMap.copyOf(outEdges), selfLoopCount);
}

 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();
 }
}

static <N, E> DirectedNetworkConnections<N, E> ofImmutable(
  Map<E, N> inEdges, Map<E, N> outEdges, int selfLoopCount) {
 return new DirectedNetworkConnections<>(
   ImmutableBiMap.copyOf(inEdges), ImmutableBiMap.copyOf(outEdges), selfLoopCount);
}

static <N, E> DirectedNetworkConnections<N, E> of() {
 return new DirectedNetworkConnections<>(
   HashBiMap.<E, N>create(EXPECTED_DEGREE), HashBiMap.<E, N>create(EXPECTED_DEGREE), 0);
}

static <N, E> DirectedNetworkConnections<N, E> of() {
 return new DirectedNetworkConnections<>(
   HashBiMap.<E, N>create(EXPECTED_DEGREE), HashBiMap.<E, N>create(EXPECTED_DEGREE), 0);
}

static <N, E> DirectedNetworkConnections<N, E> ofImmutable(
  Map<E, N> inEdges, Map<E, N> outEdges, int selfLoopCount) {
 return new DirectedNetworkConnections<>(
   ImmutableBiMap.copyOf(inEdges), ImmutableBiMap.copyOf(outEdges), selfLoopCount);
}

static <N, E> DirectedNetworkConnections<N, E> ofImmutable(
  Map<E, N> inEdges, Map<E, N> outEdges, int selfLoopCount) {
 return new DirectedNetworkConnections<>(
   ImmutableBiMap.copyOf(inEdges), ImmutableBiMap.copyOf(outEdges), selfLoopCount);
}

Javadoc

An implementation of NetworkConnections for directed networks.

Most used methods

Popular in Java

Creating JSON documents from java classes using gson
setRequestProperty (URLConnection)
putExtra (Intent)
getExternalFilesDir (Context)
Pointer (com.sun.jna)
An abstraction for a native pointer data type. A Pointer instance represents, on the Java side, a na
Point (java.awt)
A point representing a location in (x,y) coordinate space, specified in integer precision.
ConnectException (java.net)
A ConnectException is thrown if a connection cannot be established to a remote host on a specific po
HttpServlet (javax.servlet.http)
Provides an abstract class to be subclassed to create an HTTP servlet suitable for a Web site. A sub
Options (org.apache.commons.cli)
Main entry-point into the library. Options represents a collection of Option objects, which describ
Project (org.apache.tools.ant)
Central representation of an Ant project. This class defines an Ant project with all of its targets,
Top plugins for WebStorm

How to useDirectedNetworkConnections in com.google.common.graph

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

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