@Override public SortedMap<K, V> tailMap(K fromKey) { return asMap(backingSet().tailSet(fromKey), function); }
private static <N, E> Map<E, EndpointPair<N>> edgeIncidentNodesMap(final Network<N, E> network) { Function<E, EndpointPair<N>> edgeToIncidentNodesFn = new Function<E, EndpointPair<N>>() { @Override public EndpointPair<N> apply(E edge) { return network.incidentNodes(edge); } }; return Maps.asMap(network.edges(), edgeToIncidentNodesFn); } }
@Override public NavigableMap<K, V> headMap(K toKey, boolean inclusive) { return asMap(set.headSet(toKey, inclusive), function); }
@Override public NavigableMap<K, V> subMap( K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) { return asMap(set.subSet(fromKey, fromInclusive, toKey, toInclusive), function); }
@Override public NavigableMap<K, V> descendingMap() { return asMap(set.descendingSet(), function); } }
private static <N, V> Map<EndpointPair<N>, V> edgeValueMap(final ValueGraph<N, V> graph) { Function<EndpointPair<N>, V> edgeToValueFn = new Function<EndpointPair<N>, V>() { @Override public V apply(EndpointPair<N> edge) { return graph.edgeValue(edge.nodeU(), edge.nodeV()); } }; return Maps.asMap(graph.edges(), edgeToValueFn); } }
@Override public SortedMap<K, V> headMap(K toKey) { return asMap(backingSet().headSet(toKey), function); }
@Override public NavigableMap<K, V> tailMap(K fromKey, boolean inclusive) { return asMap(set.tailSet(fromKey, inclusive), function); }
@Override public SortedMap<K, V> subMap(K fromKey, K toKey) { return asMap(backingSet().subSet(fromKey, toKey), function); }
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.edgeValue(node, successorNode); } }; 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, 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); } }