@Override public Optional<Edge> reversed() { final Optional<Edge> reversed = super.reversed(); if (reversed.isPresent()) { return Optional.of(reversed.get().directionalized()); } else { return reversed; } }
@Override public Optional<Route> reverse() { return this.edge.hasReverseEdge() ? Optional.of(new SingleRoute(this.edge.reversed() .orElseThrow(() -> new CoreException("Edge should have a reverse.")))) : Optional.empty(); }
/** * @return the master for this {@link Edge}, which may or may not be the master. */ public Edge getMasterEdge() { return this.isMasterEdge() ? this : this.reversed() .orElseThrow(() -> new CoreException( "Reverse edge should be available for edge {}", this.getIdentifier())); }
building.getOsmIdentifier(), edge.getOsmIdentifier())); knownIntersections.add(edge); final Optional<Edge> reversedEdge = edge.reversed(); if (reversedEdge.isPresent())
@Override public Optional<Route> reverse() { Route reversed = null; final Iterator<Edge> iterator = this.iterator(); while (iterator.hasNext()) { final Edge edge = iterator.next(); if (edge.hasReverseEdge()) { final Edge reverse = edge.reversed().orElseThrow( () -> new CoreException("Edge should have a reverse edge.")); if (reversed == null) { reversed = Route.forEdge(reverse); } else { reversed = reversed.prepend(reverse); } } else { return Optional.empty(); } } return Optional.ofNullable(reversed); }
/** * Flags the given edge and its reverse edge * * @param edge * The edge to flag */ private void flagEdge(final Edge edge) { this.markAsFlagged(edge.getIdentifier()); if (edge.hasReverseEdge()) { this.markAsFlagged(edge.reversed().get().getIdentifier()); } }
/** * Checks if the supplied edge or its reverse edge has already been flagged * * @param edge * edge to check * @return {@code true} if the reverse edge has already been flagged */ private boolean hasBeenFlagged(final Edge edge) { if (edge.hasReverseEdge()) { return this.isFlagged(edge.getIdentifier()) || this.isFlagged(edge.reversed().get().getIdentifier()); } else { return this.isFlagged(edge.getIdentifier()); } }
@Test public void testDirectionalizedTags() { final Atlas atlas = this.rule.getAtlas(); final Edge edge6 = atlas.edge(6L).directionalized(); final Edge edge7 = atlas.edge(7L).directionalized(); final Edge edge8 = atlas.edge(8L).directionalized(); final Edge edge9 = atlas.edge(9L).directionalized(); logger.info("Edge 6: {}", edge6); Assert.assertEquals("60", edge6.tag(MaxSpeedTag.KEY)); logger.info("Edge -6: {}", edge6.reversed().get()); Assert.assertNull(edge6.reversed().get().tag(MaxSpeedTag.KEY)); logger.info("Edge 7: {}", edge7); Assert.assertNull(edge7.tag(MaxSpeedTag.KEY)); logger.info("Edge -7: {}", edge7.reversed().get()); Assert.assertEquals("70", edge7.reversed().get().tag(MaxSpeedTag.KEY)); logger.info("Edge 8: {}", edge8); Assert.assertEquals("80", edge8.tag(MaxSpeedTag.KEY)); logger.info("Edge -8: {}", edge8.reversed().get()); Assert.assertEquals("80", edge8.reversed().get().tag(MaxSpeedTag.KEY)); logger.info("Edge 9: {}", edge9); Assert.assertEquals("90", edge9.tag(MaxSpeedTag.KEY)); logger.info("Edge -9: {}", edge9.reversed().get()); Assert.assertEquals("10", edge9.reversed().get().tag(MaxSpeedTag.KEY)); }
protected void validateReverseEdgePolyLineUpdated() { for (final Edge edge : this.atlas .edges(edge -> edge.hasReverseEdge() && edge.isMasterEdge())) { final Edge reversed = edge.reversed().orElseThrow(() -> new CoreException( "Edge {} should have a reverse, but does not.", edge.getIdentifier())); final PolyLine forward = edge.asPolyLine(); final PolyLine backward = reversed.asPolyLine(); if (!forward.equals(backward.reversed())) { throw new CoreException( "Edge {} and its reverse {} have mismatching PolyLines: Forward = {}, Backward = {}", edge.getIdentifier(), reversed.getIdentifier(), forward, backward); } } } }
final Edge reverseEdge = edge.reversed().get(); // NOSONAR final long reverseEdgeIdentifier = reverseEdge.getIdentifier(); if (builder.peek().edge(reverseEdgeIdentifier) == null)
final Edge reverse = edge.reversed().get(); if (builder.peek().edge(reverse.getIdentifier()) == null)
final Edge reverse = edge.reversed().get(); if (builder.peek().edge(reverse.getIdentifier()) == null)
inEdge.reversed().ifPresent(reversed -> members .addItem(reversed.getIdentifier(), "from", ItemType.EDGE)); members.addItem(node.getIdentifier(), "via", ItemType.NODE); members.addItem(outEdge.getIdentifier(), "to", ItemType.EDGE); outEdge.reversed().ifPresent(reversed -> members .addItem(reversed.getIdentifier(), "to", ItemType.EDGE)); final Long relationIdentifier = identifierGenerator.incrementAndGet(); FeatureChange.add(CompleteEdge.shallowFrom(inEdge.reversed().get()) .withRelationIdentifiers(mergeRelationMembers( inEdge.relations(), relationIdentifier)))); FeatureChange.add(CompleteEdge.shallowFrom(outEdge.reversed().get()) .withRelationIdentifiers(mergeRelationMembers( outEdge.relations(), relationIdentifier))));