Uses of Class
org.openstreetmap.josm.data.osm.Way

Packages that use Way

Package	Description
org.openstreetmap.josm.actions	Provides the classes for JOSM user actions.
org.openstreetmap.josm.actions.corrector	Provides the classes for JOSM tag correctors.
org.openstreetmap.josm.actions.mapmode	Provides the classes for JOSM map modes.
org.openstreetmap.josm.command	Provides the classes for JOSM commands allowing to modify an OSM data set.
org.openstreetmap.josm.command.conflict	Provides commands for handling conflicts.
org.openstreetmap.josm.data.osm	Provides the classes for OSM data: Primitives: Node, Way, Relation Users Tags Changesets Utilities classes
org.openstreetmap.josm.data.osm.event	Provides the classes for OSM dataset events.
org.openstreetmap.josm.data.osm.history	Provides the classes for OSM primitives history (edition revisions).
org.openstreetmap.josm.data.osm.visitor	Provides the classes for performing actions on OSM primitives using Visitor design pattern.
org.openstreetmap.josm.data.osm.visitor.paint.relations	Provides the classes for painting and caching Multipolygon relations.
org.openstreetmap.josm.data.validation	Provides the classes for JOSM data validation.
org.openstreetmap.josm.data.validation.tests	Provides the classes for JOSM data validation tests.
org.openstreetmap.josm.data.validation.util	Provides utilities classes for JOSM data validation.
org.openstreetmap.josm.gui	Provides the classes for JOSM graphical user interface.
org.openstreetmap.josm.gui.conflict.pair.nodes	Provides the classes for displaying conflicts in ways list of nodes.
org.openstreetmap.josm.gui.dialogs	Provides three kinds of dialogs: Toggle dialogs on the right side of the GUI, that can be turned on, off, attached or detached from the GUI Changeset dialog based on a standalone implementation, dedicated to OSM changesets management Extended dialogs for everything else
org.openstreetmap.josm.gui.dialogs.relation.sort	Provides the classes for sorting relations.
org.openstreetmap.josm.gui.history	Provides GUI classes for handling history of OSM objects.
org.openstreetmap.josm.gui.layer	Provides classes for handling the different kinds of map layers.
org.openstreetmap.josm.gui.layer.validation	Provides classes for handling validation layer.
org.openstreetmap.josm.gui.mappaint	Drawing system allowing to display and render OSM map data in a user-friendly and customizable way, through map styles. Two implementations are provided: XML: this was the system used by default JOSM map style for a long time.
org.openstreetmap.josm.gui.mappaint.mapcss	Drawing system based on MapCSS map styles.
org.openstreetmap.josm.io	Provides the classes for JOSM input/output support.
org.openstreetmap.josm.tools	Provides the classes for various utilities and tools called from all other packages.

Uses of Way in org.openstreetmap.josm.actions

Fields in org.openstreetmap.josm.actions declared as Way

Modifier and Type	Field	Description
private Way	JoinAreasAction.Multipolygon.outerWay
(package private) Way	SplitWayAction.SegmentToKeepSelectionDialog.selectedWay
private Way	UnGlueAction.selectedWay
Way	JoinAreasAction.WayInPolygon.way
(package private) Way	SplitWayAction.SegmentToKeepSelectionDialog.wayToKeep

Fields in org.openstreetmap.josm.actions with type parameters of type Way

Modifier and Type	Field	Description
private java.util.function.Consumer<java.util.List<Way>>	SimplifyWayAction.SimplifyWayDataSelectionListener.consumer
private java.util.List<Way>	JoinAreasAction.Multipolygon.innerWays
(package private) javax.swing.JList<Way>	SplitWayAction.SegmentToKeepSelectionDialog.list
(package private) java.util.List<Way>	SplitWayAction.SegmentToKeepSelectionDialog.newWays
private java.util.Collection<Way>	CreateMultipolygonAction.CreateUpdateMultipolygonTask.selectedWays
private java.util.List<Way>	SimplifyWayAction.SimplifyWayDataSelectionListener.wayList
private java.util.List<Way>	SimplifyWayAction.SimplifyChangeListener.ways

Methods in org.openstreetmap.josm.actions that return Way

Modifier and Type	Method	Description
private Way	SelectNonBranchingWaySequences.findWay(java.util.Collection<OsmPrimitive> selection)	Finds out if the current selection can be extended.
private static Way	SelectNonBranchingWaySequences.findWay(java.util.Collection<OsmPrimitive> selection, Node node)	Finds out if the current selection can be extended.
Way	JoinAreasAction.Multipolygon.getOuterWay()	Returns the outer way.
protected static Way	CombineWayAction.getTargetWay(java.util.Collection<Way> combinedWays)
private Way	JoinAreasAction.joinOrientedWays(java.util.List<JoinAreasAction.WayInPolygon> ways)	Joins a list of ways (using CombineWayAction and ReverseWayAction as specified in WayInPath)
private Way	JoinAreasAction.joinWays(java.util.List<JoinAreasAction.WayInPolygon> ways)	Joins the outer ways and deletes all short ways that can't be part of a multipolygon anyway.
private Way	JoinAreasAction.keepOlder(Way way, java.util.Map<Node,Way> oldestWayMap, java.util.List<Way> discardedWays)	Create copy of given way using an older id so that we don't create a new way instead of a modified old one.

Methods in org.openstreetmap.josm.actions that return types with arguments of type Way

Modifier and Type	Method	Description
static Pair<Way,Command>	CombineWayAction.combineWaysWorker(java.util.Collection<Way> ways)	Combine multiple ways into one.
(package private) static java.util.List<Way>	SplitWayAction.getApplicableWays(java.util.List<Way> selectedWays, java.util.List<Node> selectedNodes)	Determine which ways to split.
(package private) static java.util.List<Way>	UnJoinNodeWayAction.getApplicableWays(java.util.List<Way> selectedWays, java.util.List<Node> selectedNodes)	Find ways to which the disconnect can be applied.
java.util.List<Way>	JoinAreasAction.Multipolygon.getInnerWays()	Returns the inner ways.
private java.util.List<Way>	JoinAreasAction.splitWayOnNodes(Way way, java.util.Set<Node> nodes, java.util.Map<Node,Way> oldestWayMap)	This is a method that splits way into smaller parts, using the prepared nodes list as split points.

Methods in org.openstreetmap.josm.actions with parameters of type Way

Modifier and Type	Method	Description
private boolean	UnGlueAction.addCheckedChangeNodesCmd(java.util.List<Command> cmds, Way w, java.util.List<Node> nodes)
private void	SelectNonBranchingWaySequences.addNodes(Way way)	Add the endpoints of the way to nodes, outerNodes
private static java.util.List<java.util.List<Node>>	JoinAreasAction.buildNodeChunks(Way way, java.util.Collection<Node> splitNodes)	Simple chunking version.
static SequenceCommand	SimplifyWayAction.createSimplifyCommand(Way w)	Creates the SequenceCommand to simplify a way with default threshold.
static SequenceCommand	SimplifyWayAction.createSimplifyCommand(Way w, double threshold)	Creates the SequenceCommand to simplify a way with a given threshold.
private static SequenceCommand	SimplifyWayAction.createSimplifyCommand(Way w, double threshold, boolean deselect)	Creates the SequenceCommand to simplify a way with a given threshold.
(package private) static void	SplitWayAction.doSplitWay(Way way, Way wayToKeep, java.util.List<Way> newWays, java.util.List<OsmPrimitive> newSelection)
static void	SplitWayAction.doSplitWayShowSegmentSelection(Way splitWay, java.util.List<Node> splitNodes, java.util.List<OsmPrimitive> selection)	Perform way splitting after presenting the user with a choice which way segment history should be preserved (in expert mode)
private void	JoinAreasAction.fixRelations(java.util.List<JoinAreasAction.RelationRole> rels, Way outer, JoinAreasAction.RelationRole ownMultipol, java.util.Set<Relation> relationsToDelete)	Adds the previously removed relations again to the outer way.
private static java.util.Set<Node>	SimplifyWayAction.getMultiUseNodes(Way w)	Calculate a set of nodes which occurs more than once in the way
protected static boolean	SimplifyWayAction.isRequiredNode(Way way, Node node, java.util.Set<Node> multipleUseNodes)	Replies true if node is a required node which can't be removed in order to simplify the way.
private Way	JoinAreasAction.keepOlder(Way way, java.util.Map<Node,Way> oldestWayMap, java.util.List<Way> discardedWays)	Create copy of given way using an older id so that we don't create a new way instead of a modified old one.
private static java.util.List<Node>	UnGlueAction.modifyWay(Node originalNode, Way w, java.util.List<Command> cmds, java.util.List<Node> newNodes)	dupe the given node of the given way assume that originalNode is in the way the new node will be put into the parameter newNodes. the add-node command will be put into the parameter cmds. the changed way will be returned and must be put into cmds by the caller!
private static java.util.List<Node>	CreateCircleAction.orderNodesByWay(java.util.List<Node> nodes, Way way)	Order nodes according to way direction.
static ReverseWayAction.ReverseWayResult	ReverseWayAction.reverseWay(Way w)	Reverses a given way.
private java.util.List<Way>	JoinAreasAction.splitWayOnNodes(Way way, java.util.Set<Node> nodes, java.util.Map<Node,Way> oldestWayMap)	This is a method that splits way into smaller parts, using the prepared nodes list as split points.
private boolean	UnGlueAction.unglueClosedOrSelfCrossingWay(Way way, PropertiesMembershipChoiceDialog dialog)	Duplicates a node used several times by the same way.
private void	UnGlueAction.unglueOneNodeAtMostOneWay(Way way, PropertiesMembershipChoiceDialog dialog)	Assumes there is one tagged Node stored in selectedNode that it will try to unglue.
void	UploadSelectionAction.UploadHullBuilder.visit(Way w)

Method parameters in org.openstreetmap.josm.actions with type arguments of type Way

Modifier and Type	Method	Description
(package private) void	SimplifyWayAction.SimplifyWayDataSelectionListener.addConsumer(java.util.function.Consumer<java.util.List<Way>> wayConsumer)
private JoinAreasAction.RelationRole	JoinAreasAction.addOwnMultipolygonRelation(java.util.Collection<Way> inner)	Will add own multipolygon relation to the "previously existing" relations.
private static Command	AlignInLineAction.alignMultiWay(java.util.Collection<Way> ways)	Align way in case of multiple way #6819
static double	SimplifyWayAction.askSimplifyWays(java.util.List<Way> ways, java.lang.String text, boolean auto)	Asks the user for max-err value used to simplify ways, if not remembered before
private static double	SimplifyWayAction.askSimplifyWays(java.util.List<Way> ways, java.util.function.Supplier<java.lang.String> textSupplier, SimplifyWayAction.SimplifyWayDataSelectionListener listener, boolean auto)	Asks the user for max-err value used to simplify ways, if not remembered before
private static SequenceCommand	SimplifyWayAction.buildSimplifyWaysCommand(java.util.List<Way> ways, double threshold)	Creates the commands to simplify the ways with the given threshold
protected java.util.Set<Relation>	UnGlueAction.calcAffectedRelations(java.util.Collection<Way> ways)
private static boolean	CombineWayAction.checkAndConfirmCombineOutlyingWays(java.util.Collection<Way> ways)	Check whether user is about to combine ways with unknown parents.
private static boolean	DistributeAction.checkDistributeNodes(java.util.Collection<Way> ways, java.util.Collection<Node> nodes)	Test if nodes oriented algorithm applies to the selection.
private static boolean	DistributeAction.checkDistributeWay(java.util.Collection<Way> ways, java.util.Collection<Node> nodes)	Test if one way, no self-crossing, is selected with at most two of its nodes.
private java.util.List<Node>	UnJoinNodeWayAction.cleanSelectedNodes(java.util.List<Way> selectedWays, java.util.List<Node> selectedNodes)	Removes irrelevant nodes from user selection.
static java.util.List<JoinAreasAction.Multipolygon>	JoinAreasAction.collectMultipolygons(java.util.Collection<Way> selectedWays)	This method analyzes multipolygon relationships of given ways and collects addition inner ways to consider.
private static java.util.List<Node>	AlignInCircleAction.collectNodesAnticlockwise(java.util.List<Way> ways)	Assuming all ways can be joined into polygon, create an ordered list of node.
private static java.util.List<Node>	AlignInCircleAction.collectNodesWithExternReferrers(java.util.List<Way> ways)	Collect all nodes with more than one referrer.
static Pair<Way,Command>	CombineWayAction.combineWaysWorker(java.util.Collection<Way> ways)	Combine multiple ways into one.
static Pair<SequenceCommand,Relation>	CreateMultipolygonAction.createMultipolygonCommand(java.util.Collection<Way> selectedWays, Relation selectedMultipolygonRelation)	Returns a Pair of a multipolygon creating/modifying Command as well as the multipolygon Relation.
static Pair<Relation,Relation>	CreateMultipolygonAction.createMultipolygonRelation(java.util.Collection<Way> selectedWays, boolean showNotif)	Returns a Pair null and the newly created/modified multipolygon Relation.
protected static void	CombineWayAction.detectReversedWays(java.util.Collection<Way> ways, java.util.List<Node> path, java.util.List<Way> reversedWays, java.util.List<Way> unreversedWays)
private static java.util.Collection<Command>	DistributeAction.distributeWay(java.util.Collection<Way> ways, java.util.Collection<Node> nodes)	Distribute nodes contained by a way, keeping nodes order.
(package private) static void	SplitWayAction.doSplitWay(Way way, Way wayToKeep, java.util.List<Way> newWays, java.util.List<OsmPrimitive> newSelection)
static java.util.List<JoinAreasAction.AssembledPolygon>	JoinAreasAction.findBoundaryPolygons(java.util.Collection<JoinAreasAction.WayInPolygon> multigonWays, java.util.List<Way> discardedResult)	Finds all ways that form inner or outer boundaries.
(package private) static java.util.List<Way>	SplitWayAction.getApplicableWays(java.util.List<Way> selectedWays, java.util.List<Node> selectedNodes)	Determine which ways to split.
(package private) static java.util.List<Way>	UnJoinNodeWayAction.getApplicableWays(java.util.List<Way> selectedWays, java.util.List<Node> selectedNodes)	Find ways to which the disconnect can be applied.
private static java.util.List<AlignInLineAction.Line>	AlignInLineAction.getInvolvedLines(Node node, java.util.List<Way> refWays)	Get lines useful to do alignment of a single node
private static Relation	CreateMultipolygonAction.getSelectedMultipolygonRelation(java.util.Collection<Way> selectedWays, java.util.Collection<Relation> selectedRelations)
protected static Way	CombineWayAction.getTargetWay(java.util.Collection<Way> combinedWays)
private static boolean	UnGlueAction.isRelationAffected(Relation r, java.util.Set<Node> affectedNodes, java.util.Collection<Way> ways)
void	JoinAreasAction.join(java.util.Collection<Way> ways)	Joins the given ways.
private static java.util.List<Node>	CombineWayAction.joinWithMultipolygonCode(java.util.Collection<Way> ways)	Use Multipolygon.joinWays(Collection) to join ways.
private Way	JoinAreasAction.keepOlder(Way way, java.util.Map<Node,Way> oldestWayMap, java.util.List<Way> discardedWays)	Create copy of given way using an older id so that we don't create a new way instead of a modified old one.
private Way	JoinAreasAction.keepOlder(Way way, java.util.Map<Node,Way> oldestWayMap, java.util.List<Way> discardedWays)	Create copy of given way using an older id so that we don't create a new way instead of a modified old one.
private static java.util.List<JoinAreasAction.WayInPolygon>	JoinAreasAction.markWayInsideSide(java.util.List<Way> parts, boolean isInner)	This method analyzes the way and assigns each part what direction polygon "inside" is.
protected void	UnGlueAction.notifyWayPartOfRelation(java.util.Collection<Way> ways)
private boolean	JoinAreasAction.removeDuplicateNodes(java.util.List<Way> ways)	This method removes duplicate points (if any) from the input ways.
static void	SimplifyWayAction.simplifyWays(java.util.List<Way> ways, double threshold)	Runs the commands to simplify the ways with the given threshold
static int	SimplifyWayAction.simplifyWaysCountNodesRemoved(java.util.List<Way> ways, double threshold)	Runs the commands to simplify the ways with the given threshold
private java.util.List<Way>	JoinAreasAction.splitWayOnNodes(Way way, java.util.Set<Node> nodes, java.util.Map<Node,Way> oldestWayMap)	This is a method that splits way into smaller parts, using the prepared nodes list as split points.
private void	JoinAreasAction.stripTags(java.util.Collection<Way> ways)	Remove all tags from the all the way
protected static java.util.List<Node>	CombineWayAction.tryJoin(java.util.Collection<Way> ways)
static Pair<Relation,Relation>	CreateMultipolygonAction.updateMultipolygonRelation(java.util.Collection<Way> selectedWays, Relation selectedMultipolygonRelation)	Returns a Pair of the old multipolygon Relation (or null) and the newly created/modified multipolygon Relation.

Constructors in org.openstreetmap.josm.actions with parameters of type Way

Constructor	Description
Line(Way way)	Init a line equation from a way.
Multipolygon(Way way)	Constructs a new Multipolygon.
SegmentToKeepSelectionDialog(Way selectedWay, java.util.List<Way> newWays, Way wayToKeep, java.util.List<Node> selectedNodes, java.util.List<OsmPrimitive> selection)
WayInPolygon(Way way, boolean insideRight)

Constructor parameters in org.openstreetmap.josm.actions with type arguments of type Way

Constructor	Description
CreateUpdateMultipolygonTask(java.util.Collection<Way> selectedWays, Relation multipolygonRelation)
SegmentToKeepSelectionDialog(Way selectedWay, java.util.List<Way> newWays, Way wayToKeep, java.util.List<Node> selectedNodes, java.util.List<OsmPrimitive> selection)
SelectNonBranchingWaySequences(java.util.Collection<Way> ways)	Creates a way selection
SimplifyChangeListener(javax.swing.JLabel nodesToRemove, javax.swing.SpinnerNumberModel errorModel, java.util.List<Way> ways)
SimplifyWayDataSelectionListener(java.util.List<Way> wayList)	Create a new selection listener for SimplifyWayAction

Uses of Way in org.openstreetmap.josm.actions.corrector

Methods in org.openstreetmap.josm.actions.corrector that return types with arguments of type Way

Modifier and Type	Method	Description
static java.util.List<Way>	ReverseWayTagCorrector.irreversibleWays(java.util.List<Way> ways)	Returns the subset of irreversible ways.

Methods in org.openstreetmap.josm.actions.corrector with parameters of type Way

Modifier and Type	Method	Description
static void	ReverseWayNoTagCorrector.checkAndConfirmReverseWay(Way way)	Checks the given way can be safely reversed and asks user to confirm the operation if it not the case.
private static boolean	ReverseWayNoTagCorrector.confirmReverseWay(Way way, TagCollection tags)
java.util.Collection<Command>	ReverseWayTagCorrector.execute(Way oldway, Way way)
(package private) static java.util.List<RoleCorrection>	ReverseWayTagCorrector.getRoleCorrections(Way oldway)
(package private) static java.util.Map<OsmPrimitive,java.util.List<TagCorrection>>	ReverseWayTagCorrector.getTagCorrectionsMap(Way way)
static boolean	ReverseWayTagCorrector.isReversible(Way way)	Tests whether way can be reversed without semantic change, i.e., whether tags have to be changed.

Method parameters in org.openstreetmap.josm.actions.corrector with type arguments of type Way

Modifier and Type	Method	Description
static java.util.List<Way>	ReverseWayTagCorrector.irreversibleWays(java.util.List<Way> ways)	Returns the subset of irreversible ways.

Uses of Way in org.openstreetmap.josm.actions.mapmode

Fields in org.openstreetmap.josm.actions.mapmode declared as Way

Modifier and Type	Field	Description
private Way	SplitMode.SplitWayActionConcrete.splitWay
private Way	ImproveWayAccuracyAction.targetWay

Fields in org.openstreetmap.josm.actions.mapmode with type parameters of type Way

Modifier and Type	Field	Description
private java.util.Set<Way>	DrawAction.mouseOnExistingWays
private java.util.Set<Way>	ParallelWayAction.sourceWays
private java.util.List<Way>	ParallelWays.ways

Methods in org.openstreetmap.josm.actions.mapmode that return Way

Modifier and Type	Method	Description
static Way	ImproveWayAccuracyHelper.findWay(MapView mv, java.awt.Point p)	Finds the way to work on.
static Way	DrawAction.getWayForNode(Node n)	Replies the parent way of a node, if it is the end of exactly one usable way.

Methods in org.openstreetmap.josm.actions.mapmode that return types with arguments of type Way

Modifier and Type	Method	Description
private static java.util.List<Way>	SplitMode.getApplicableWays(Node n, java.util.Collection<Way> preferredWays)	Get a list of potential ways to be split for a given node
java.util.List<Way>	ParallelWays.getWays()	Returns the resulting parallel ways.

Methods in org.openstreetmap.josm.actions.mapmode with parameters of type Way

Modifier and Type	Method	Description
private void	SplitMode.addNodeAndSplit(MapView mv, java.awt.Point mousePos, Way way)	Add a node to a way and then split it
private void	ParallelWayAction.addSourceWay(Way w)
private void	DrawAction.continueWayFromNode(Way way, Node node)	if one of the ends of way is given node, then set currentBaseNode = node and previousNode = adjacent node of way
static Node	ImproveWayAccuracyHelper.findCandidateNode(MapView mv, Way w, java.awt.Point p)	Returns the nearest node to cursor.
static WaySegment	ImproveWayAccuracyHelper.findCandidateSegment(MapView mv, Way w, java.awt.Point p)	Returns the nearest way segment to cursor.
private Node	DrawAction.findNodeToContinueFrom(Node selectedNode, Way selectedWay)	Finds a node to continue drawing from.
private static boolean	ExtrudeAction.hasNodeOtherWays(Node node, Way myWay)	This method tests if node has other ways apart from the given one.
private boolean	DrawAction.isSelfContainedWay(Way selectedWay, Node currentNode, Node targetNode)	Prevent creation of ways that look like this: <----> This happens if users want to draw a no-exit-sideway from the main way like this: ^ |<----> | The solution isn't ideal because the main way will end in the side way, which is bad for navigation software ("drive straight on") but at least easier to fix.
private void	ParallelWayAction.removeSourceWay(Way w)
void	ImproveWayAccuracyAction.startImproving(Way targetWay)	Switches to Improving state

Method parameters in org.openstreetmap.josm.actions.mapmode with type arguments of type Way

Modifier and Type	Method	Description
private javax.swing.JPopupMenu	SplitMode.createPopup(Node n, java.util.Collection<Way> applicableWays)	Create a new split way selection popup
private static java.util.List<Way>	SplitMode.getApplicableWays(Node n, java.util.Collection<Way> preferredWays)	Get a list of potential ways to be split for a given node
private static java.lang.String	DrawAction.getTitle(boolean newNode, Node n, java.util.Collection<OsmPrimitive> newSelection, java.util.Map<Way,java.util.List<Node>> reuseWays, boolean extendedWay)
private void	DrawAction.insertNodeIntoAllNearbySegments(java.util.List<WaySegment> wss, Node n, java.util.Collection<OsmPrimitive> newSelection, java.util.Collection<Command> cmds, java.util.Map<Way,java.util.List<Node>> reuseWays)
private static void	ParallelWayAction.removeWayHighlighting(java.util.Collection<Way> ways)

Constructors in org.openstreetmap.josm.actions.mapmode with parameters of type Way

Constructor	Description
SplitWayActionConcrete(Way splitWay, java.util.List<Node> splitNodes, java.util.List<OsmPrimitive> selection)	Construct an action to split way splitWay at nodes splitNodes

Constructor parameters in org.openstreetmap.josm.actions.mapmode with type arguments of type Way

Constructor	Description
ParallelWays(java.util.Collection<Way> sourceWays, boolean copyTags, int refWayIndex)	Constructs a new ParallelWays.

Uses of Way in org.openstreetmap.josm.command

Fields in org.openstreetmap.josm.command declared as Way

Modifier and Type	Field	Description
private Way	SplitWayCommand.originalWay
protected Way	AbstractNodesCommand.way

Fields in org.openstreetmap.josm.command with type parameters of type Way

Modifier and Type	Field	Description
private java.util.Set<Way>	SplitWayCommand.RelationAnalysis.neededIncompleteMembers
private java.util.List<Way>	SplitWayCommand.newWays

Methods in org.openstreetmap.josm.command that return Way

Modifier and Type	Method	Description
Way	SplitWayCommand.Strategy.determineWayToKeep(java.lang.Iterable<Way> wayChunks)	Determines which way chunk should reuse the old id and its history.
Way	SplitWayCommand.getOriginalWay()	Replies the original way being split

Methods in org.openstreetmap.josm.command that return types with arguments of type Way

Modifier and Type	Method	Description
static java.util.List<Way>	SplitWayCommand.createNewWaysFromChunks(Way way, java.lang.Iterable<java.util.List<Node>> wayChunks)	Creates new way objects for the way chunks and transfers the keys from the original way.
java.util.Set<Way>	SplitWayCommand.RelationAnalysis.getNeededIncompleteMembers()
java.util.List<Way>	SplitWayCommand.getNewWays()	Replies the resulting new ways

Methods in org.openstreetmap.josm.command with parameters of type Way

Modifier and Type	Method	Description
(package private) static SplitWayCommand.Analysis	SplitWayCommand.analyseSplit(Way way, Way wayToKeep, java.util.List<Way> newWays)
static java.util.List<java.util.List<Node>>	SplitWayCommand.buildSplitChunks(Way wayToSplit, java.util.List<Node> splitPoints)	Splits the nodes of wayToSplit into a list of node sequences which are separated at the nodes in splitPoints.
static java.util.List<Way>	SplitWayCommand.createNewWaysFromChunks(Way way, java.lang.Iterable<java.util.List<Node>> wayChunks)	Creates new way objects for the way chunks and transfers the keys from the original way.
static java.util.Optional<SplitWayCommand>	SplitWayCommand.doSplitWay(Way way, Way wayToKeep, java.util.List<Way> newWays, java.util.List<OsmPrimitive> newSelection, SplitWayCommand.WhenRelationOrderUncertain whenRelationOrderUncertain)	Effectively constructs the SplitWayCommand.
static SplitWayCommand	SplitWayCommand.split(Way way, java.util.List<Node> atNodes, java.util.Collection<? extends OsmPrimitive> selection)	Splits the way way at the nodes in atNodes and replies the result of this process in an instance of SplitWayCommand.
(package private) static SplitWayCommand	SplitWayCommand.splitBasedOnAnalyses(Way way, java.util.List<Way> newWays, java.util.List<OsmPrimitive> newSelection, SplitWayCommand.Analysis analysis, int indexOfWayToKeep)
static SplitWayCommand	SplitWayCommand.splitWay(Way way, java.util.List<java.util.List<Node>> wayChunks, java.util.Collection<? extends OsmPrimitive> selection)	Splits the way way into chunks of wayChunks and replies the result of this process in an instance of SplitWayCommand.
static SplitWayCommand	SplitWayCommand.splitWay(Way way, java.util.List<java.util.List<Node>> wayChunks, java.util.Collection<? extends OsmPrimitive> selection, SplitWayCommand.Strategy splitStrategy)	Splits the way way into chunks of wayChunks and replies the result of this process in an instance of SplitWayCommand.
static java.util.Optional<SplitWayCommand>	SplitWayCommand.splitWay(Way way, java.util.List<java.util.List<Node>> wayChunks, java.util.Collection<? extends OsmPrimitive> selection, SplitWayCommand.Strategy splitStrategy, SplitWayCommand.WhenRelationOrderUncertain whenRelationOrderUncertain)	Splits the way way into chunks of wayChunks and replies the result of this process in an instance of SplitWayCommand.
private static SplitWayCommand.RelationInformation	SplitWayCommand.treatAsRestriction(Relation r, RelationMember rm, Relation c, java.util.Collection<Way> newWays, Way way, java.util.List<Node> changedWayNodes)
void	Command.CloneVisitor.visit(Way w)

Method parameters in org.openstreetmap.josm.command with type arguments of type Way

Modifier and Type	Method	Description
private static void	SplitWayCommand.addSortedWays(int position, int indexOfWayToKeep, SplitWayCommand.Direction direction, java.util.List<Way> newWays, Relation relation)	Add ways in a sorted manner
(package private) static SplitWayCommand.Analysis	SplitWayCommand.analyseSplit(Way way, Way wayToKeep, java.util.List<Way> newWays)
Way	SplitWayCommand.Strategy.determineWayToKeep(java.lang.Iterable<Way> wayChunks)	Determines which way chunk should reuse the old id and its history.
static java.util.Optional<SplitWayCommand>	SplitWayCommand.doSplitWay(Way way, Way wayToKeep, java.util.List<Way> newWays, java.util.List<OsmPrimitive> newSelection, SplitWayCommand.WhenRelationOrderUncertain whenRelationOrderUncertain)	Effectively constructs the SplitWayCommand.
private static boolean	SplitWayCommand.needToReverseSplit(int position, int indexOfWayToKeep, Relation relation, java.util.List<Way> newWays)	This is only strictly necessary when we are splitting a route where it starts to loop back.
(package private) static SplitWayCommand	SplitWayCommand.splitBasedOnAnalyses(Way way, java.util.List<Way> newWays, java.util.List<OsmPrimitive> newSelection, SplitWayCommand.Analysis analysis, int indexOfWayToKeep)
private static SplitWayCommand.RelationInformation	SplitWayCommand.treatAsRestriction(Relation r, RelationMember rm, Relation c, java.util.Collection<Way> newWays, Way way, java.util.List<Node> changedWayNodes)

Constructors in org.openstreetmap.josm.command with parameters of type Way

Constructor	Description
AbstractNodesCommand(DataSet ds, Way way, C cmdNodes)	Constructs a new AbstractNodesCommand.
AbstractNodesCommand(Way way, C cmdNodes)	Constructs a new AbstractNodesCommand.
ChangeNodesCommand(DataSet ds, Way way, java.util.List<Node> newNodes)	Constructs a new ChangeNodesCommand.
ChangeNodesCommand(Way way, java.util.List<Node> newNodes)	Constructs a new ChangeNodesCommand.
RemoveNodesCommand(DataSet ds, Way way, java.util.Set<Node> rmNodes)	Constructs a new RemoveNodesCommand.
RemoveNodesCommand(Way way, java.util.Set<Node> rmNodes)	Constructs a new RemoveNodesCommand.
SplitWayCommand(java.lang.String name, java.util.Collection<Command> commandList, java.util.List<? extends PrimitiveId> newSelection, Way originalWay, java.util.List<Way> newWays)	Create a new SplitWayCommand.

Constructor parameters in org.openstreetmap.josm.command with type arguments of type Way

Constructor	Description
RelationAnalysis(Relation relation, RelationMember relationMember, SplitWayCommand.Direction direction, java.util.Set<Way> neededIncompleteMembers)

Uses of Way in org.openstreetmap.josm.command.conflict

Fields in org.openstreetmap.josm.command.conflict with type parameters of type Way

Modifier and Type	Field	Description
private Conflict<Way>	WayNodesConflictResolverCommand.conflict	the conflict to resolve

Uses of Way in org.openstreetmap.josm.data.osm

Fields in org.openstreetmap.josm.data.osm with type parameters of type Way

Modifier and Type	Field	Description
private QuadBucketPrimitiveStore<Node,Way,Relation>	DataSet.store
java.util.List<Way>	MultipolygonBuilder.JoinedPolygon.ways	list of ways building this polygon

Methods in org.openstreetmap.josm.data.osm that return Way

Modifier and Type	Method	Description
Way	DataSet.getLastSelectedWay()	Returns the way selected last or null if no way primitives were selected or selection is empty.
Way	RelationMember.getWay()	Returns the relation member as a way.
private static Way	OsmUtils.newWay(LatLon around, boolean enforceLocation)
Way	WaySegment.toWay()	Returns this way segment as complete way.

Methods in org.openstreetmap.josm.data.osm that return types with arguments of type Way

Modifier and Type	Method	Description
java.util.List<Way>	Node.getParentWays()	Replies the list of referring ways.
java.util.Collection<Way>	DataSet.getWays()
java.util.List<Way>	DataSet.searchWays(BBox bbox)
java.util.Set<Way>	DataSet.unlinkNodeFromWays(Node node)	Removes all references from ways in this dataset to a particular node.

Methods in org.openstreetmap.josm.data.osm with parameters of type Way

Modifier and Type	Method	Description
static java.util.List<NodePair>	NodeGraph.buildNodePairs(Way way, boolean directed)	Builds a list of pair of nodes from the given way.
boolean	DataSet.containsWay(Way w)	Determines if the given way can be retrieved in the data set through its bounding box.
private static void	DataSet.deleteWay(Way way)
(package private) void	DataSet.fireWayNodesChanged(Way way)
protected void	DataSetMerger.fixIncomplete(Way other)
static WaySegment	WaySegment.forNodePair(Way way, Node first, Node second)	Determines and returns the way segment for the given way and node pair.
private void	DataSetMerger.mergeNodeList(Way source)	Merges the node list of a source way onto its target way.

Method parameters in org.openstreetmap.josm.data.osm with type arguments of type Way

Modifier and Type	Method	Description
static java.util.List<NodePair>	NodeGraph.buildNodePairs(java.util.List<Way> ways, boolean directed)	Builds a list of pair of nodes from the given ways.
static NodeGraph	NodeGraph.createDirectedGraphFromWays(java.util.Collection<Way> ways)	Create a directed graph from the given ways.
static NodeGraph	NodeGraph.createNearlyUndirectedGraphFromNodeWays(java.util.Collection<Way> ways)	Create a nearly undirected graph from the given ways, but prevent reversing of all non-new ways by fixing one direction.
static NodeGraph	NodeGraph.createUndirectedGraphFromNodeWays(java.util.Collection<Way> ways)	Create an undirected graph from the given ways, but prevent reversing of all non-new ways by fixing one direction.
static java.util.List<MultipolygonBuilder.JoinedPolygon>	MultipolygonBuilder.joinWays(java.util.Collection<Way> ways)	Joins the given ways to multipolygon rings.
java.lang.String	MultipolygonBuilder.makeFromWays(java.util.Collection<Way> ways)	Splits ways into inner and outer JoinedWays.

Constructors in org.openstreetmap.josm.data.osm with parameters of type Way

Constructor	Description
JoinedPolygon(Way way)	Creates a polygon from single way.
Way(Way original)	Constructs a new Way from an existing Way (including its id).
Way(Way original, boolean clearMetadata)	Constructs a new Way from an existing Way.
Way(Way original, boolean clearMetadata, boolean copyNodes)	Constructs a new Way from an existing Way.
WaySegment(Way way, int i)	Constructs a new IWaySegment.

Constructor parameters in org.openstreetmap.josm.data.osm with type arguments of type Way

Constructor	Description
JoinedPolygon(java.util.List<Way> ways, java.util.List<java.lang.Boolean> reversed)	Constructs a new JoinedPolygon from given list of ways.

Uses of Way in org.openstreetmap.josm.data.osm.event

Fields in org.openstreetmap.josm.data.osm.event declared as Way

Modifier and Type	Field	Description
private Way	WayNodesChangedEvent.way

Methods in org.openstreetmap.josm.data.osm.event that return Way

Modifier and Type	Method	Description
Way	WayNodesChangedEvent.getChangedWay()	Returns the way affected by the change.

Constructors in org.openstreetmap.josm.data.osm.event with parameters of type Way

Constructor	Description
WayNodesChangedEvent(DataSet dataSet, Way way)	Constructs a new WayNodesChangedEvent.

Uses of Way in org.openstreetmap.josm.data.osm.history

Constructors in org.openstreetmap.josm.data.osm.history with parameters of type Way

Constructor	Description
HistoryWay(Way w)	Constructs a new HistoryWay from an existing Way.

Uses of Way in org.openstreetmap.josm.data.osm.visitor

Methods in org.openstreetmap.josm.data.osm.visitor with parameters of type Way

Modifier and Type	Method	Description
protected void	MergeSourceBuildingVisitor.rememberWay(Way w)	remembers a way in the hull
void	AllNodesVisitor.visit(Way w)	Ways have their way nodes.
void	BoundingXYVisitor.visit(Way w)
void	MergeSourceBuildingVisitor.visit(Way w)
void	OsmPrimitiveVisitor.visit(Way w)	Visiting call for lines.

Uses of Way in org.openstreetmap.josm.data.osm.visitor.paint.relations

Fields in org.openstreetmap.josm.data.osm.visitor.paint.relations with type parameters of type Way

Modifier and Type	Field	Description
private java.util.List<Way>	Multipolygon.innerWays
private java.util.List<Way>	Multipolygon.outerWays

Methods in org.openstreetmap.josm.data.osm.visitor.paint.relations that return types with arguments of type Way

Modifier and Type	Method	Description
java.util.List<Way>	Multipolygon.getInnerWays()	Replies the list of inner ways.
java.util.List<Way>	Multipolygon.getOuterWays()	Replies the list of outer ways.

Method parameters in org.openstreetmap.josm.data.osm.visitor.paint.relations with type arguments of type Way

Modifier and Type	Method	Description
private void	Multipolygon.createPolygons(java.util.List<Way> ways, java.util.List<Multipolygon.PolyData> result)
static java.util.Collection<Multipolygon.JoinedWay>	Multipolygon.joinWays(java.util.Collection<Way> waysToJoin)	Attempt to combine the ways in the list if they share common end nodes

Constructors in org.openstreetmap.josm.data.osm.visitor.paint.relations with parameters of type Way

Constructor	Description
PolyData(Way closedWay)	Constructs a new PolyData from a closed way.

Uses of Way in org.openstreetmap.josm.data.validation

Methods in org.openstreetmap.josm.data.validation with parameters of type Way

Modifier and Type	Method	Description
void	Test.TagTest.visit(Way w)
void	Test.visit(Way w)

Uses of Way in org.openstreetmap.josm.data.validation.tests

Fields in org.openstreetmap.josm.data.validation.tests declared as Way

Modifier and Type	Field	Description
Way	UnconnectedWays.MyWaySegment.w	the way

Fields in org.openstreetmap.josm.data.validation.tests with type parameters of type Way

Modifier and Type	Field	Description
private java.util.Map<java.awt.geom.Point2D,java.util.List<Way>>	SimilarNamedWays.cellWays	All ways, grouped by cells
private java.util.List<Way>	Coastlines.coastlineWays
private MultiMap<Way,Way>	SimilarNamedWays.errorWays	The already detected errors
private MultiMap<Way,Way>	SimilarNamedWays.errorWays	The already detected errors
private java.util.Collection<Way>	PowerLines.foundPowerLines
private java.util.Map<java.util.List<Way>,java.util.List<WaySegment>>	CrossingWays.seenWays	The already detected ways in error
private java.util.Set<Way>	CycleDetector.usableWaterways	All waterways for cycle detection
private java.util.Set<Way>	LongSegment.visitedWays	set of visited ways.
private java.util.List<Way>	DuplicateWay.waysToCheck
private java.util.Set<Way>	CrossingWays.waysToTest
private java.util.Set<Way>	UnconnectedWays.waysToTest
private java.util.Set<Way>	UntaggedWay.waysUsedInRelations
private java.util.Set<Way>	PowerLines.wrongLineType

Methods in org.openstreetmap.josm.data.validation.tests that return Way

Modifier and Type	Method	Description
protected Way	UnconnectedWays.getWantedParentWay(Node endnode)	An unconnected node might have multiple parent ways, e.g.

Methods in org.openstreetmap.josm.data.validation.tests that return types with arguments of type Way

Modifier and Type	Method	Description
private java.util.Collection<Way>	CrossingWays.addNearbyObjects()
private java.util.Collection<Way>	CycleDetector.buildGraph(Way way)	Returns a collection of ways, which belongs to the same graph.
private static java.util.Map<java.util.List<Way>,java.util.List<WaySegment>>	MultipolygonTest.findIntersectingWays(Relation r, boolean findSharedWaySegments)	See CrossingWays
private java.util.Collection<java.util.Collection<Way>>	CycleDetector.getGraphs()	Returns all directional waterways which connect to at least one other usable way.

Methods in org.openstreetmap.josm.data.validation.tests with parameters of type Way

Modifier and Type	Method	Description
private void	Coastlines.addError(int errCode, Way w, java.util.Collection<Way> otherWays, Node n)	Add error if not already done
private void	WayConnectedToArea.addPossibleError(Way w, Node wayNode, OsmPrimitive p, OsmPrimitive area)
private void	PowerLines.addWaterWaySegments(Way w)	Add segments to the appropriate cells
private static boolean	CrossingWays.areLayerOrLevelDifferent(Way w1, Way w2)
private java.util.Collection<Way>	CycleDetector.buildGraph(Way way)	Returns a collection of ways, which belongs to the same graph.
private void	SharpAngles.checkAngle(Node node1, Node node2, Node node3, int i, Way way, boolean last)
protected static java.util.Set<WaySegment>	OverlappingWays.checkDuplicateWaySegment(Way w)
private void	TurnrestrictionTest.checkIfConnected(Relation r, Way previous, Way current, java.lang.String msg, int code)
private void	Coastlines.checkIfReversed(Way w, Way other, Node n1)	Check if a reversed way would fit, if yes, add fixable "reversed" error, "unordered" else
private void	DuplicateWay.checkWay(Way w)
void	SharpAngles.checkWayForSharpAngles(Way way)	Check nodes in a way for sharp angles
(package private) CrossingWays.MessageHelper	CrossingWays.createMessage(Way w1, Way w2)
(package private) CrossingWays.MessageHelper	CrossingWays.Ways.createMessage(Way w1, Way w2)
private void	SharpAngles.createNearlyOverlappingError(double angle, Way way, OsmPrimitive primitive)
(package private) static boolean	PowerLines.detectDiscontinuity(Way way, java.util.Set<OsmPrimitive> nRefDiscontinuities, java.util.List<java.util.Set<Node>> sRefDiscontinuities)	Detects ref=* numbering discontinuities in the given way.
private static void	PowerLines.findCrossings(java.util.Map<java.awt.geom.Point2D,java.util.List<WaySegment>> ways, Way parent, java.util.Set<Way> crossingWays, java.util.Set<ILatLon> crossingPositions)	Searches for way intersections, which intersect the pair attribute.
static void	CrossingWays.findIntersectingWay(Way w, java.util.Map<java.awt.geom.Point2D,java.util.List<WaySegment>> cellSegments, java.util.Map<java.util.List<Way>,java.util.List<WaySegment>> crossingWays, boolean findSharedWaySegments)	Find ways which are crossing without sharing a node.
private static java.util.Set<java.lang.String>	CrossingWays.Boundaries.getBoundaryTags(Way w)	Collect all boundary tag values of the way and its parent relations
static java.util.List<LatLon>	DuplicateWay.getOrderedNodes(Way w)	Replies the ordered list of nodes of way w such as it is easier to find duplicated ways.
TestError	UnclosedWays.UnclosedWaysCheck.getTestError(Way w, UnclosedWays test)	Returns the test error of the given way, if any.
(package private) java.util.List<UnconnectedWays.MyWaySegment>	UnconnectedWays.getWaySegments(Way w)
private void	Highways.handleCarWay(Node n, Way w)
private void	Highways.handleCyclistWay(Node n, Way w)
private void	Highways.handlePedestrianWay(Node n, Way w)
private boolean	LongSegment.ignoreWay(Way w)
(package private) boolean	CrossingWays.Boundaries.ignoreWaySegmentCombination(Way w1, Way w2)
(package private) abstract boolean	CrossingWays.ignoreWaySegmentCombination(Way w1, Way w2)
(package private) boolean	CrossingWays.SelfCrossing.ignoreWaySegmentCombination(Way w1, Way w2)
(package private) boolean	CrossingWays.Ways.ignoreWaySegmentCombination(Way w1, Way w2)
private boolean	UnconnectedWays.MyWaySegment.isConnectedTo(Node node, java.util.Set<Node> visited, double len, Way parent)	Check if the given node is connected to this segment using a reasonable short way.
private static boolean	PowerLines.isConnectedToStationLine(Node n, Way w)	Determines if the current node connected to a line which usually used inside power stations.
private static boolean	CycleDetector.isConsecutive(Way w, Node n, Node m)	Determines if the given nodes are consecutive part of the parent way.
private static boolean	PowerLines.isContinuesAsMinorLine(Way way)	Checks if the way continues as a power=minor_line.
private static boolean	TurnrestrictionTest.isFullOneway(Way w)
static boolean	Highways.isHighwayLinkOkay(Way way)	Determines if the given link road is correct, see https://wiki.openstreetmap.org/wiki/Highway_link.
private boolean	UnconnectedWays.MyWaySegment.isObstacle(Way w)
private static boolean	OverlappingWays.isOtherLinear(Way way)
protected static boolean	PowerLines.isPowerLine(Way w)	Determines if the specified way denotes a power line.
private static boolean	PowerLines.isRelatedToPower(Way way)
static boolean	CrossingWays.isSelfCrossing(Way way)	Check if the given way is self crossing
static boolean	SelfIntersectingWay.isSelfIntersecting(Way way)	Check if the given way is self-intersecting
private static boolean	Highways.isSpecialArea(Way w)	Check if way is an area on a layer above or below 0.
private static boolean	DirectionNodes.isSuitableParentWay(Way w)
protected boolean	UnconnectedWays.isWantedWay(Way w)
(package private) static CrossingWays.WayType	CrossingWays.WayType.of(Way w)
private void	PowerLines.powerlineChecks(Way w)	The base powerline checks
private void	SharpAngles.processSharpAngleForErrorCreation(double angle, int i, Way way, boolean last, Node pointNode)
private void	WronglyOrderedWays.reportError(Way w, java.lang.String msg, int type)
private void	PowerLines.RefChecker.run(Way way)
boolean	SharpAngles.shouldBeTestedForSharpAngles(Way way)	Check whether a way should be checked for sharp angles
private void	WayConnectedToArea.testForError(Way w, Node wayNode, OsmPrimitive p)
private void	Highways.testHighwayLink(Way way)
private void	CrossingWays.testWay(Way w)
private void	LongSegment.testWay(Way w)
private void	Highways.testWrongRoundabout(Way w)
void	Addresses.visit(Way w)
void	ApiCapabilitiesTest.visit(Way w)
void	Coastlines.visit(Way way)
void	CrossingWays.visit(Way w)
void	CycleDetector.visit(Way w)
void	DuplicatedWayNodes.visit(Way w)
void	DuplicateWay.visit(Way w)
void	Highways.visit(Way w)
void	LongSegment.visit(Way w)
void	OverlappingWays.visit(Way w)
void	PowerLines.visit(Way w)
void	RightAngleBuildingTest.visit(Way w)
void	SelfIntersectingWay.visit(Way w)
void	SharpAngles.visit(Way way)
void	SimilarNamedWays.visit(Way w)
void	UnclosedWays.visit(Way w)
void	UnconnectedWays.visit(Way w)
void	UntaggedWay.visit(Way w)
void	WayConnectedToArea.visit(Way w)
void	WronglyOrderedWays.visit(Way w)
private void	LongSegment.visitWaySegment(Way w, int i)

Method parameters in org.openstreetmap.josm.data.validation.tests with type arguments of type Way

Modifier and Type	Method	Description
private void	Coastlines.addError(int errCode, Way w, java.util.Collection<Way> otherWays, Node n)	Add error if not already done
private void	OverlappingWays.analyseOverlaps(java.util.Set<WaySegment> duplicated, java.util.Map<java.util.List<Way>,java.util.Set<WaySegment>> seenWays)
protected void	Addresses.checkDistance(OsmPrimitive house, java.util.Collection<Way> street)
private static boolean	Highways.checkLayer(Node connection, java.util.List<Way> ways)	Check if there are at least two neighbouring nodes on the given ways.
private static void	PowerLines.findCrossings(java.util.Map<java.awt.geom.Point2D,java.util.List<WaySegment>> ways, Way parent, java.util.Set<Way> crossingWays, java.util.Set<ILatLon> crossingPositions)	Searches for way intersections, which intersect the pair attribute.
private static boolean	MultipolygonTest.hasIntersectionWay(Multipolygon.PolyData pd, java.util.Set<Way> intersectionWays)	Simple check if given ring contains way that is known to intersect.
Relation	MultipolygonTest.makeFromWays(java.util.Collection<Way> ways)	Create a multipolygon relation from the given ways and test it.

Constructors in org.openstreetmap.josm.data.validation.tests with parameters of type Way

Constructor	Description
MyWaySegment(Way w, Node n1, Node n2, boolean concersArea)
RefChecker(Way way)

Uses of Way in org.openstreetmap.josm.data.validation.util

Methods in org.openstreetmap.josm.data.validation.util that return types with arguments of type Way

Modifier and Type	Method	Description
static java.util.List<java.util.List<Way>>	ValUtil.getWaysInCell(Way w, java.util.Map<java.awt.geom.Point2D,java.util.List<Way>> cellWays)	Returns the start and end cells of a way.

Methods in org.openstreetmap.josm.data.validation.util with parameters of type Way

Modifier and Type	Method	Description
static java.util.List<java.util.List<Way>>	ValUtil.getWaysInCell(Way w, java.util.Map<java.awt.geom.Point2D,java.util.List<Way>> cellWays)	Returns the start and end cells of a way.
void	AggregatePrimitivesVisitor.visit(Way w)
void	NameVisitor.visit(Way w)	If the way has a name-key or id-key, this is displayed.

Method parameters in org.openstreetmap.josm.data.validation.util with type arguments of type Way

Modifier and Type	Method	Description
static java.util.List<java.util.List<Way>>	ValUtil.getWaysInCell(Way w, java.util.Map<java.awt.geom.Point2D,java.util.List<Way>> cellWays)	Returns the start and end cells of a way.

Uses of Way in org.openstreetmap.josm.gui

Methods in org.openstreetmap.josm.gui that return Way

Modifier and Type	Method	Description
Way	NavigatableComponent.getNearestWay(java.awt.Point p, java.util.function.Predicate<OsmPrimitive> predicate)	The *result* depends on the current map selection state.

Methods in org.openstreetmap.josm.gui that return types with arguments of type Way

Modifier and Type	Method	Description
java.util.List<Way>	NavigatableComponent.getNearestWays(java.awt.Point p, java.util.Collection<Way> ignore, java.util.function.Predicate<OsmPrimitive> predicate)	The *result* does not depend on the current map selection state, neither does the result *order*.
java.util.List<Way>	NavigatableComponent.getNearestWays(java.awt.Point p, java.util.function.Predicate<OsmPrimitive> predicate)	The *result* does not depend on the current map selection state, neither does the result *order*.

Method parameters in org.openstreetmap.josm.gui with type arguments of type Way

Modifier and Type	Method	Description
java.util.List<Way>	NavigatableComponent.getNearestWays(java.awt.Point p, java.util.Collection<Way> ignore, java.util.function.Predicate<OsmPrimitive> predicate)	The *result* does not depend on the current map selection state, neither does the result *order*.
void	MapStatus.setDist(java.util.Collection<Way> ways)	Sets the distance text to the total sum of given ways length

Uses of Way in org.openstreetmap.josm.gui.conflict.pair.nodes

Methods in org.openstreetmap.josm.gui.conflict.pair.nodes with parameters of type Way

Modifier and Type	Method	Description
void	NodeListMergeModel.populate(Way my, Way their, java.util.Map<PrimitiveId,PrimitiveId> mergedMap)	Populates the model with the nodes in the two Ways my and their.

Uses of Way in org.openstreetmap.josm.gui.dialogs

Methods in org.openstreetmap.josm.gui.dialogs with parameters of type Way

Modifier and Type	Method	Description
void	ConflictDialog.ConflictPainter.visit(Way w)

Uses of Way in org.openstreetmap.josm.gui.dialogs.relation.sort

Methods in org.openstreetmap.josm.gui.dialogs.relation.sort with parameters of type Way

Modifier and Type	Method	Description
private static boolean	WayConnectionTypeCalculator.isConnected(Way way1, Way way2)

Uses of Way in org.openstreetmap.josm.gui.history

Methods in org.openstreetmap.josm.gui.history with parameters of type Way

Modifier and Type	Method	Description
void	HistoryBrowserModel.HistoryPrimitiveBuilder.visit(Way w)

Uses of Way in org.openstreetmap.josm.gui.layer

Methods in org.openstreetmap.josm.gui.layer with parameters of type Way

Modifier and Type	Method	Description
void	OsmDataLayer.DataCountVisitor.visit(Way w)

Method parameters in org.openstreetmap.josm.gui.layer with type arguments of type Way

Modifier and Type	Method	Description
private static void	OsmDataLayer.waysToGpxData(java.util.Collection<Way> ways, GpxData gpxData, java.util.Set<Node> doneNodes, java.lang.String gpxPrefix)

Uses of Way in org.openstreetmap.josm.gui.layer.validation

Methods in org.openstreetmap.josm.gui.layer.validation with parameters of type Way

Modifier and Type	Method	Description
void	PaintVisitor.visit(Way w)

Uses of Way in org.openstreetmap.josm.gui.mappaint

Fields in org.openstreetmap.josm.gui.mappaint with type parameters of type Way

Modifier and Type	Field	Description
java.util.Map<IPrimitive,java.util.Map<java.util.List<Way>,java.util.List<WaySegment>>>	Environment.crossingWaysMap	Crossing ways result from CrossingFinder, filled for incomplete ways/relations

Uses of Way in org.openstreetmap.josm.gui.mappaint.mapcss

Methods in org.openstreetmap.josm.gui.mappaint.mapcss that return types with arguments of type Way

Modifier and Type	Method	Description
private java.util.Map<java.util.List<Way>,java.util.List<WaySegment>>	Selector.ChildOrParentSelector.CrossingFinder.findCrossings(IPrimitive area, java.util.Map<java.awt.geom.Point2D,java.util.List<WaySegment>> cellSegments)

Uses of Way in org.openstreetmap.josm.io

Fields in org.openstreetmap.josm.io with type parameters of type Way

Modifier and Type	Field	Description
private static java.util.Set<Way>	GeoJSONWriter.processedMultipolygonWays

Methods in org.openstreetmap.josm.io that return Way

Modifier and Type	Method	Description
protected Way	AbstractReader.parseWay(AbstractReader.CommonReader commonReader, AbstractReader.WayReader wayReader)
protected Way	OsmReader.parseWay()

Methods in org.openstreetmap.josm.io that return types with arguments of type Way

Modifier and Type	Method	Description
private java.util.Optional<Way>	GeoJSONReader.createWay(jakarta.json.JsonArray coordinates, boolean autoClose)
private java.util.Optional<Way>	GeoJSONReader.parseLineString(jakarta.json.JsonObject feature, jakarta.json.JsonArray coordinates)

Methods in org.openstreetmap.josm.io with parameters of type Way

Modifier and Type	Method	Description
MultiFetchServerObjectReader	MultiFetchServerObjectReader.appendWay(Way way)	appends a Way id and the list of ids of nodes the way refers to the list of ids which will be fetched from the server.
void	GeoJSONWriter.GeometryPrimitiveVisitor.visit(Way w)

Method parameters in org.openstreetmap.josm.io with type arguments of type Way

Modifier and Type	Method	Description
void	OsmWriter.writeWays(java.util.Collection<Way> ways)	Writes the given ways sorted by id

Uses of Way in org.openstreetmap.josm.tools

Methods in org.openstreetmap.josm.tools with parameters of type Way

Modifier and Type	Method	Description
private static void	RightAndLefthandTraffic.addWayIfNotInner(java.util.Collection<Way> ways, Way w)	Adds w to ways, except if it is an inner way of another lefthand driving multipolygon, as Lesotho in South Africa and Cyprus village in British Cyprus base.
static double	Geometry.closedWayArea(Way way)	Returns area of a closed way in square meters.
static WaySegment	Geometry.getClosestWaySegment(Way way, OsmPrimitive primitive)	Get the closest WaySegment from a way to a primitive.
static double	Geometry.getDistanceWayNode(Way way, Node node)	Get the distance between a way and a node
static double	Geometry.getDistanceWayWay(Way w1, Way w2)	Get the distance between different ways.
static java.lang.Double	RotationAngle.WayDirectionRotationAngle.getRotationAngleForNodeOnWay(Node n, Way w)	Calculates the rotation angle of a node in a way based on the preceding way segment.
static boolean	Geometry.isClockwise(Way w)	Determines whether a way is oriented clockwise.

Method parameters in org.openstreetmap.josm.tools with type arguments of type Way

Modifier and Type	Method	Description
static java.util.Set<Node>	Geometry.addIntersections(java.util.List<Way> ways, boolean test, java.util.List<Command> cmds)	Will find all intersection and add nodes there for list of given ways.
private static void	RightAndLefthandTraffic.addWayIfNotInner(java.util.Collection<Way> ways, Way w)	Adds w to ways, except if it is an inner way of another lefthand driving multipolygon, as Lesotho in South Africa and Cyprus village in British Cyprus base.
(package private) static void	RightAndLefthandTraffic.appendLeftDrivingBoundaries(OsmPrimitive osm, java.util.Collection<Way> ways)
static boolean	Geometry.isNodeInsideMultiPolygon(INode node, Relation multiPolygon, java.util.function.Predicate<Way> isOuterWayAMatch)	Tests if the node is inside the multipolygon multiPolygon.
static boolean	Geometry.isPolygonInsideMultiPolygon(java.util.List<? extends INode> nodes, Relation multiPolygon, java.util.function.Predicate<Way> isOuterWayAMatch)	Tests if the polygon formed by nodes is inside the multipolygon multiPolygon.
static boolean	Geometry.isPolygonInsideMultiPolygon(java.util.List<? extends INode> nodes, Pair<java.util.List<MultipolygonBuilder.JoinedPolygon>,java.util.List<MultipolygonBuilder.JoinedPolygon>> outerInner, java.util.function.Predicate<Way> isOuterWayAMatch)	Tests if the polygon formed by nodes is inside the multipolygon multiPolygon.

Constructor parameters in org.openstreetmap.josm.tools with type arguments of type Way

Constructor	Description
DefaultGeoProperty(java.util.Collection<Way> ways)	Create DefaultGeoProperty based on a collection of closed ways.