Changeset 24091 in osm


Ignore:
Timestamp:
2010-11-06T18:37:31+01:00 (14 years ago)
Author:
oliverw
Message:

AddressNode -> OSMAddress

Location:
applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses
Files:
16 edited
1 moved

Legend:

Unmodified
Added
Removed

  • applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/AddressEditContainer.java

    r24090 r24091  
    7777       
    7878        /** The unresolved addresses list. */
    79         private List<AddressNode> unresolvedAddresses = new ArrayList<AddressNode>(100);
     79        private List<OSMAddress> unresolvedAddresses = new ArrayList<OSMAddress>(100);
    8080       
    8181        /** The incomplete addresses list. */
    82         private List<AddressNode> incompleteAddresses = new ArrayList<AddressNode>(100);
     82        private List<OSMAddress> incompleteAddresses = new ArrayList<OSMAddress>(100);
    8383       
    8484        /** The shadow copy to assemble the street dict during update. */
    8585        private HashMap<String, StreetNode> shadowStreetDict = new HashMap<String, StreetNode>(100);
    8686        /** The shadow copy to assemble the unresolved addresses during update. */
    87         private List<AddressNode> shadowUnresolvedAddresses = new ArrayList<AddressNode>(100);
     87        private List<OSMAddress> shadowUnresolvedAddresses = new ArrayList<OSMAddress>(100);
    8888        /** The shadow copy to assemble the incomplete addresses during update. */
    89         private List<AddressNode> shadowIncompleteAddresses = new ArrayList<AddressNode>(100);
     89        private List<OSMAddress> shadowIncompleteAddresses = new ArrayList<OSMAddress>(100);
    9090       
    9191        /** The visited nodes cache to increase iteration speed. */
    … …  
    208208                }
    209209
    210                 AddressNode aNode = null;
     210                OSMAddress aNode = null;
    211211                // Address nodes are recycled in order to keep instance variables like guessed names
    212212                aNode = NodeFactory.createNode(n);
    … …  
    239239         * @param aNode the address node to add and check
    240240         */
    241         private void addAndClassifyAddress(AddressNode aNode) {
     241        private void addAndClassifyAddress(OSMAddress aNode) {
    242242                if (!assignAddressToStreet(aNode)) {
    243243                        // Assignment failed: Street is not known (yet) -> add to 'unresolved' list
    … …  
    317317
    318318                        // Node is an address
    319                         if (ne instanceof AddressNode) {
    320                                 AddressNode aNode = (AddressNode) ne;
     319                        if (ne instanceof OSMAddress) {
     320                                OSMAddress aNode = (OSMAddress) ne;
    321321                                addAndClassifyAddress(aNode);
    322322                                return true;
    … …  
    353353         * @return the unresolved addresses
    354354         */
    355         public List<AddressNode> getUnresolvedAddresses() {
     355        public List<OSMAddress> getUnresolvedAddresses() {
    356356                return unresolvedAddresses;
    357357        }
    … …  
    362362         * @return the incomplete addresses
    363363         */
    364         public List<AddressNode> getIncompleteAddresses() {
     364        public List<OSMAddress> getIncompleteAddresses() {
    365365                return incompleteAddresses;
    366366        }
    … …  
    381381         * @return
    382382         */
    383         public List<AddressNode> getUnresolvedItems() {
     383        public List<OSMAddress> getUnresolvedItems() {
    384384                return unresolvedAddresses;
    385385        }
    … …  
    431431                int sum = 0;
    432432                               
    433                 for (AddressNode aNode : getAllAddressesToFix()) {
     433                for (OSMAddress aNode : getAllAddressesToFix()) {
    434434                        if (aNode.hasGuesses()) {
    435435                                sum++;
    … …  
    443443         * @return
    444444         */
    445         public List<AddressNode> getAllAddressesToFix() {
    446                 List<AddressNode> all = new ArrayList<AddressNode>(incompleteAddresses);
    447 
    448                 for (AddressNode aNode : unresolvedAddresses) {
     445        public List<OSMAddress> getAllAddressesToFix() {
     446                List<OSMAddress> all = new ArrayList<OSMAddress>(incompleteAddresses);
     447
     448                for (OSMAddress aNode : unresolvedAddresses) {
    449449                        if (!all.contains(aNode)) {
    450450                                all.add(aNode);
    … …  
    459459         * @param aNode
    460460         */
    461         private boolean assignAddressToStreet(AddressNode aNode) {
     461        private boolean assignAddressToStreet(OSMAddress aNode) {
    462462                String streetName = aNode.getStreetName();
    463463               
    … …  
    475475         */
    476476        public void resolveAddresses() {
    477                 List<AddressNode> resolvedAddresses = new ArrayList<AddressNode>();
    478                 for (AddressNode node : shadowUnresolvedAddresses) {
     477                List<OSMAddress> resolvedAddresses = new ArrayList<OSMAddress>();
     478                for (OSMAddress node : shadowUnresolvedAddresses) {
    479479                        if (assignAddressToStreet(node)) {
    480480                                resolvedAddresses.add(node);
    … …  
    483483               
    484484                /* Remove all resolves nodes from unresolved list */
    485                 for (AddressNode resolved : resolvedAddresses) {
     485                for (OSMAddress resolved : resolvedAddresses) {
    486486                        shadowUnresolvedAddresses.remove(resolved);
    487487                }
    … …  
    522522
    523523                        // put results from shadow copy into real lists
    524                         incompleteAddresses = new ArrayList<AddressNode>(shadowIncompleteAddresses);
    525                         unresolvedAddresses = new ArrayList<AddressNode>(shadowUnresolvedAddresses);
     524                        incompleteAddresses = new ArrayList<OSMAddress>(shadowIncompleteAddresses);
     525                        unresolvedAddresses = new ArrayList<OSMAddress>(shadowUnresolvedAddresses);
    526526                        streetDict = new HashMap<String, StreetNode>(shadowStreetDict);
    527527                        // remove temp data

  • applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/AddressFinderThread.java

    r24088 r24091  
    3737 *
    3838 * The guessing procedure itself is implemented by defining "guessers" using the {@link GuessedValueHandler}
    39  * class. A guessed field does not modify the corresponding property of {@link AddressNode} itself, but
    40  * adds the guessed value to a shadowed field by calling {@link AddressNode#setGuessedValue(String, String)}. 
     39 * class. A guessed field does not modify the corresponding property of {@link OSMAddress} itself, but
     40 * adds the guessed value to a shadowed field by calling {@link OSMAddress#setGuessedValue(String, String)}. 
    4141 */
    4242public class AddressFinderThread extends PleaseWaitRunnable implements Visitor {
    43         private List<AddressNode> addressesToGuess;
     43        private List<OSMAddress> addressesToGuess;
    4444        private List<IProgressMonitorFinishedListener> finishListeners = new ArrayList<IProgressMonitorFinishedListener>();
    4545        private double minDist;
    46         private AddressNode curAddressNode;
     46        private OSMAddress curAddressNode;
    4747        private boolean isRunning = false;     
    4848        private boolean cancelled;
    … …  
    5151         * @param nodes
    5252         */
    53         public AddressFinderThread(List<AddressNode> nodes, String title) {
     53        public AddressFinderThread(List<OSMAddress> nodes, String title) {
    5454                super(title != null ? title : tr("Searching"));
    5555                setAddressEditContainer(nodes);         
    5656        }
    5757
    58         public void setAddressEditContainer(List<AddressNode> nodes) {
     58        public void setAddressEditContainer(List<OSMAddress> nodes) {
    5959                if (isRunning) {
    6060                        throw new ConcurrentModificationException();
    … …  
    6363        }
    6464
    65         public List<AddressNode> getAddressesToGuess() {
     65        public List<OSMAddress> getAddressesToGuess() {
    6666                return addressesToGuess;
    6767        }
    … …  
    182182                       
    183183                       
    184                         List<AddressNode> shadowCopy = new ArrayList<AddressNode>(addressesToGuess);
    185                         for (AddressNode aNode : shadowCopy) {                                 
     184                        List<OSMAddress> shadowCopy = new ArrayList<OSMAddress>(addressesToGuess);
     185                        for (OSMAddress aNode : shadowCopy) {                                   
    186186                                minDist = Double.MAX_VALUE;
    187187                                curAddressNode = aNode;
    … …  
    235235        private class GuessStreetValueHandler extends GuessedValueHandler {
    236236
    237                 public GuessStreetValueHandler(String tag, AddressNode aNode) {
     237                public GuessStreetValueHandler(String tag, OSMAddress aNode) {
    238238                        super(tag, aNode);
    239239                }
    … …  
    253253                public void visit(Way w) {                     
    254254                        if (TagUtils.isStreetSupportingHousenumbers(w)) {
    255                                 AddressNode aNode = getAddressNode();
     255                                OSMAddress aNode = getAddressNode();
    256256                                double dist = OsmUtils.getMinimumDistanceToWay(aNode.getCoor(), w);
    257257                                if (dist < minDist && dist < getMaxDistance()) {

  • applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/GuessedValueHandler.java

    r24088 r24091  
    3535        protected double minDist;
    3636        protected String currentValue;
    37         private AddressNode aNode;
     37        private OSMAddress aNode;
    3838        private double maxDist = DEFAULT_MAX_DIST;
    3939       
    … …  
    4545         * @param maxDist the maximum distance for a node/way to be considered as guessed value.
    4646         */
    47         public GuessedValueHandler(String tag, AddressNode aNode) {
     47        public GuessedValueHandler(String tag, OSMAddress aNode) {
    4848                this(tag, aNode, DEFAULT_MAX_DIST);
    4949        }
    … …  
    5656         * @param maxDist the maximum distance for a node/way to be considered as guessed value.
    5757         */
    58         public GuessedValueHandler(String tag, AddressNode aNode, double maxDist) {
     58        public GuessedValueHandler(String tag, OSMAddress aNode, double maxDist) {
    5959                super();
    6060               
    … …  
    8282         * @return the aNode
    8383         */
    84         protected AddressNode getAddressNode() {
     84        protected OSMAddress getAddressNode() {
    8585                return aNode;
    8686        }

  • applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/NodeFactory.java

    r24089 r24091  
    2020
    2121public class NodeFactory {
    22         private static HashMap<String, AddressNode> addressCache = new HashMap<String, AddressNode>();
     22        private static HashMap<String, OSMAddress> addressCache = new HashMap<String, OSMAddress>();
    2323       
    2424        /**
    … …  
    2727         * @return
    2828         */
    29         public static AddressNode createNode(Node node) {
     29        public static OSMAddress createNode(Node node) {
    3030                if (TagUtils.isAddress(node)) {
    3131                        String aid = "" + node.getId();
    3232                       
    33                         AddressNode aNode = lookup(aid);
     33                        OSMAddress aNode = lookup(aid);
    3434                        if (aNode == null) {
    35                                 aNode = new AddressNode(node);
     35                                aNode = new OSMAddress(node);
    3636                                addressCache.put(aid, aNode);
    3737                        } else {
    … …  
    5858                        String aid = "" + way.getId();
    5959                       
    60                         AddressNode aNode = lookup(aid);
     60                        OSMAddress aNode = lookup(aid);
    6161                        if (aNode == null) {
    62                                 aNode = new AddressNode(way);
     62                                aNode = new OSMAddress(way);
    6363                                addressCache.put(aid, aNode);
    6464                        } else {
    … …  
    7171        }
    7272       
    73         private static AddressNode lookup(String aid) {                         
     73        private static OSMAddress lookup(String aid) {                         
    7474                if (addressCache.containsKey(aid)) {
    7575                        return addressCache.get(aid);                   

  • applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/OSMAddress.java

    r24090 r24091  
    1919
    2020/**
    21  * The class AddressNode represents a single address node of OSM. It is a lightweight
     21 * The class OSMAddress represents a single address node of OSM. It is a lightweight
    2222 * wrapper for a OSM node in order to simplify tag handling.
    2323 */
    24 public class AddressNode extends OSMEntityBase {
     24public class OSMAddress extends OSMEntityBase {
    2525        public static final String MISSING_TAG = "?";
    2626       
    … …  
    3030        private HashMap<String, String> derivedValues = new HashMap<String, String>();
    3131
    32         public AddressNode(OsmPrimitive osmObject) {
     32        public OSMAddress(OsmPrimitive osmObject) {
    3333                super(osmObject);
    3434        }
    … …  
    276276        @Override
    277277        public int compareTo(IOSMEntity o) {
    278                 if (o == null || !(o instanceof AddressNode)) {
     278                if (o == null || !(o instanceof OSMAddress)) {
    279279                        return -1;
    280280                }
    281                 AddressNode other = (AddressNode) o;
     281                OSMAddress other = (OSMAddress) o;
    282282               
    283283                int cc = 0;
    … …  
    467467        @Override
    468468        public String toString() {
    469                 return AddressNode.getFormatString(this);
    470         }
    471 
    472         public static String getFormatString(AddressNode node) {
     469                return OSMAddress.getFormatString(this);
     470        }
     471
     472        public static String getFormatString(OSMAddress node) {
    473473                // TODO: Add further countries here
    474474                // DE

  • applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/SelectIncompleteAddressesAction.java

    r23967 r24091  
    4242                        List<OsmPrimitive> osms = new ArrayList<OsmPrimitive>();
    4343                       
    44                         for (AddressNode aNode : addressEditContainer.getIncompleteAddresses()) {
     44                        for (OSMAddress aNode : addressEditContainer.getIncompleteAddresses()) {
    4545                                osms.add(aNode.getOsmObject());
    4646                        }

  • applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/StreetNode.java

    r24090 r24091  
    2828public class StreetNode extends OSMEntityBase {
    2929        private List<IOSMEntity> children;
    30         private List<AddressNode> addresses;
     30        private List<OSMAddress> addresses;
    3131                       
    3232        /**
    … …  
    5858        }
    5959       
    60         public void addAddress(AddressNode aNode) {
     60        public void addAddress(OSMAddress aNode) {
    6161                lazyCreateAddresses();
    6262                addresses.add(aNode);           
    … …  
    6565        private void lazyCreateAddresses() {
    6666                if (addresses == null) {
    67                         addresses = new ArrayList<AddressNode>();
     67                        addresses = new ArrayList<OSMAddress>();
    6868                }
    6969        }
    … …  
    7373        }
    7474       
    75         public List<AddressNode> getAddresses() {
     75        public List<OSMAddress> getAddresses() {
    7676                return addresses;
    7777        }
    7878       
    79         public void setAddresses(List<AddressNode> addresses) {
     79        public void setAddresses(List<OSMAddress> addresses) {
    8080                this.addresses = addresses;
    8181        }

  • applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/gui/AddressEditDialog.java

    r24089 r24091  
    5050import org.openstreetmap.josm.gui.SideButton;
    5151import org.openstreetmap.josm.plugins.fixAddresses.AddressEditContainer;
    52 import org.openstreetmap.josm.plugins.fixAddresses.AddressNode;
     52import org.openstreetmap.josm.plugins.fixAddresses.OSMAddress;
    5353import org.openstreetmap.josm.plugins.fixAddresses.IAddressEditContainerListener;
    5454import org.openstreetmap.josm.plugins.fixAddresses.IOSMEntity;
    … …  
    275275                        // show addresses as blue marker
    276276                        if (sNode.hasAddresses()) {
    277                                 for (AddressNode aNode : sNode.getAddresses()) {
     277                                for (OSMAddress aNode : sNode.getAddresses()) {
    278278                                        Color markerCol = Color.BLUE;
    279279                                        if (!aNode.isComplete()) {
    … …  
    285285                }
    286286               
    287                 List<AddressNode> unrAddresses = ev.getSelectedUnresolvedAddresses();
     287                List<OSMAddress> unrAddresses = ev.getSelectedUnresolvedAddresses();
    288288                if (unrAddresses != null) {
    289                         for (AddressNode aNode : unrAddresses) {                                       
     289                        for (OSMAddress aNode : unrAddresses) {                                 
    290290                                mapViewer.addMapMarker(new MapMarkerDot(Color.ORANGE, aNode.getCoor().lat(), aNode.getCoor().lon()));
    291291                        }

  • applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/gui/AddressEditModel.java

    r24089 r24091  
    2222import javax.swing.tree.TreeNode;
    2323
    24 import org.openstreetmap.josm.plugins.fixAddresses.AddressNode;
     24import org.openstreetmap.josm.plugins.fixAddresses.OSMAddress;
    2525import org.openstreetmap.josm.plugins.fixAddresses.IOSMEntity;
    2626import org.openstreetmap.josm.plugins.fixAddresses.StreetNode;
    … …  
    2828public class AddressEditModel {
    2929        private List<StreetNode> streets;
    30         private List<AddressNode> unresolvedAddresses;
    31         private List<AddressNode> incompleteAddresses = new ArrayList<AddressNode>();
     30        private List<OSMAddress> unresolvedAddresses;
     31        private List<OSMAddress> incompleteAddresses = new ArrayList<OSMAddress>();
    3232        private DefaultMutableTreeNode streetRoot;
    3333        private DefaultMutableTreeNode unresolvedRoot;
    … …  
    3939         */
    4040        public AddressEditModel(List<StreetNode> streets,
    41                         List<AddressNode> unresolvedAddresses) {
     41                        List<OSMAddress> unresolvedAddresses) {
    4242                super();
    4343                this.streets = streets;
    … …  
    6666                                        treeStreetNode.add(addressNode);
    6767                                       
    68                                         for (AddressNode addr : sNode.getAddresses()) {
     68                                        for (OSMAddress addr : sNode.getAddresses()) {
    6969                                                addressNode.add(new DefaultMutableTreeNode(addr));
    7070                                                if (!addr.isComplete()) {
    … …  
    9090                        unresolvedRoot = new DefaultMutableTreeNode();
    9191                       
    92                         for (AddressNode addr : unresolvedAddresses) {
     92                        for (OSMAddress addr : unresolvedAddresses) {
    9393                                // Add address nodes                           
    9494                                unresolvedRoot.add(new DefaultMutableTreeNode(addr));
    … …  
    109109                        incompleteRoot = new DefaultMutableTreeNode();
    110110                       
    111                         for (AddressNode addr : incompleteAddresses) {
     111                        for (OSMAddress addr : incompleteAddresses) {
    112112                                // Add address nodes                           
    113113                                incompleteRoot.add(new DefaultMutableTreeNode(addr));

  • applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/gui/AddressEditSelectionEvent.java

    r23941 r24091  
    2121
    2222import org.openstreetmap.josm.plugins.fixAddresses.AddressEditContainer;
    23 import org.openstreetmap.josm.plugins.fixAddresses.AddressNode;
     23import org.openstreetmap.josm.plugins.fixAddresses.OSMAddress;
    2424import org.openstreetmap.josm.plugins.fixAddresses.StreetNode;
    2525
    … …  
    8989         * @return
    9090         */
    91         public List<AddressNode> getSelectedUnresolvedAddresses() {
     91        public List<OSMAddress> getSelectedUnresolvedAddresses() {
    9292                if (unresolvedAddressTable != null &&
    9393                                addressContainer != null &&
    … …  
    9696                        int[] selRows = unresolvedAddressTable.getSelectedRows();
    9797                       
    98                         List<AddressNode> nodes = new ArrayList<AddressNode>();
     98                        List<OSMAddress> nodes = new ArrayList<OSMAddress>();
    9999                        for (int i = 0; i < selRows.length; i++) {
    100100                                if (selRows[i] >= 0 && selRows[i] < addressContainer.getNumberOfUnresolvedAddresses()) {

  • applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/gui/ApplyAllGuessesAction.java

    r24089 r24091  
    2525
    2626import org.openstreetmap.josm.plugins.fixAddresses.AddressEditContainer;
    27 import org.openstreetmap.josm.plugins.fixAddresses.AddressNode;
     27import org.openstreetmap.josm.plugins.fixAddresses.OSMAddress;
    2828import org.openstreetmap.josm.plugins.fixAddresses.IOSMEntity;
    2929
    … …  
    4646                if (ev == null || ev.getSelectedUnresolvedAddresses() == null) return;
    4747                // fix SELECTED items only
    48                 List<AddressNode> addrToFix = ev.getSelectedUnresolvedAddresses();
     48                List<OSMAddress> addrToFix = ev.getSelectedUnresolvedAddresses();
    4949                applyGuesses(addrToFix);
    5050        }
    … …  
    5555        }
    5656
    57         private void applyGuesses(List<AddressNode> addrToFix) {
     57        private void applyGuesses(List<OSMAddress> addrToFix) {
    5858                beginTransaction(tr("Applied guessed values"));
    59                 List<AddressNode> addrToFixShadow = new ArrayList<AddressNode>(addrToFix);
    60                 for (AddressNode aNode : addrToFixShadow) {
     59                List<OSMAddress> addrToFixShadow = new ArrayList<OSMAddress>(addrToFix);
     60                for (OSMAddress aNode : addrToFixShadow) {
    6161                        beginObjectTransaction(aNode);
    6262                        aNode.applyAllGuesses();
    … …  
    7575                if (container == null || container.getUnresolvedAddresses() == null) return;
    7676               
    77                 List<AddressNode> addrToFix = container.getUnresolvedAddresses();
     77                List<OSMAddress> addrToFix = container.getUnresolvedAddresses();
    7878                applyGuesses(addrToFix);               
    7979        }
    … …  
    8888                                int row = table.rowAtPoint(p);
    8989                                IOSMEntity node = model.getEntityOfRow(row);
    90                                 if (node instanceof AddressNode) {
     90                                if (node instanceof OSMAddress) {
    9191                                        beginTransaction(tr("Applied guessed values for ") + node.getOsmObject());
    9292                                        beginObjectTransaction(node);
    93                                         AddressNode aNode = (AddressNode) node;
     93                                        OSMAddress aNode = (OSMAddress) node;
    9494                                        if (aNode.hasGuessedStreetName()) {
    9595                                                aNode.applyAllGuesses();

  • applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/gui/AssignAddressToStreetAction.java

    r23970 r24091  
    1717
    1818import org.openstreetmap.josm.plugins.fixAddresses.AddressEditContainer;
    19 import org.openstreetmap.josm.plugins.fixAddresses.AddressNode;
     19import org.openstreetmap.josm.plugins.fixAddresses.OSMAddress;
    2020import org.openstreetmap.josm.plugins.fixAddresses.StreetNode;
    2121
    … …  
    4646                if (streetNode != null && ev.getSelectedUnresolvedAddresses() != null) {
    4747                        beginTransaction(tr("Set street name") + " '" + streetNode.getName() + "'");
    48                         for (AddressNode addrNode : ev.getSelectedUnresolvedAddresses()) {
     48                        for (OSMAddress addrNode : ev.getSelectedUnresolvedAddresses()) {
    4949                                beginObjectTransaction(addrNode);
    5050                                addrNode.assignStreet(streetNode);

  • applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/gui/GuessAddressDataAction.java

    r24023 r24091  
    2121import org.openstreetmap.josm.plugins.fixAddresses.AddressEditContainer;
    2222import org.openstreetmap.josm.plugins.fixAddresses.AddressFinderThread;
    23 import org.openstreetmap.josm.plugins.fixAddresses.AddressNode;
     23import org.openstreetmap.josm.plugins.fixAddresses.OSMAddress;
    2424import org.openstreetmap.josm.plugins.fixAddresses.IProgressMonitorFinishedListener;
    2525
    … …  
    8080         * @param addrNodes
    8181         */
    82         private void internalGuessAddresses(List<AddressNode> nodes) {
     82        private void internalGuessAddresses(List<OSMAddress> nodes) {
    8383                AddressFinderThread aft = new AddressFinderThread(nodes, tr("Guess street names"));
    8484                aft.addFinishListener(this);

  • applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/gui/IncompleteAddressesTableModel.java

    r24089 r24091  
    1717
    1818import org.openstreetmap.josm.plugins.fixAddresses.AddressEditContainer;
    19 import org.openstreetmap.josm.plugins.fixAddresses.AddressNode;
     19import org.openstreetmap.josm.plugins.fixAddresses.OSMAddress;
    2020import org.openstreetmap.josm.plugins.fixAddresses.IOSMEntity;
    2121
    … …  
    6060        @Override
    6161        public Object getValueAt(int row, int column) {         
    62                 AddressNode aNode = (AddressNode) getEntityOfRow(row);
     62                OSMAddress aNode = (OSMAddress) getEntityOfRow(row);
    6363               
    6464                if (aNode == null) {

  • applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/gui/RemoveAddressTagsAction.java

    r23970 r24091  
    1717
    1818import org.openstreetmap.josm.plugins.fixAddresses.AddressEditContainer;
    19 import org.openstreetmap.josm.plugins.fixAddresses.AddressNode;
     19import org.openstreetmap.josm.plugins.fixAddresses.OSMAddress;
    2020
    2121@SuppressWarnings("serial")
    … …  
    2929        public void addressEditActionPerformed(AddressEditSelectionEvent ev) {
    3030                beginTransaction(tr("Remove address tags"));
    31                 for (AddressNode aNode : ev.getSelectedUnresolvedAddresses()) {
     31                for (OSMAddress aNode : ev.getSelectedUnresolvedAddresses()) {
    3232                        beginObjectTransaction(aNode);
    3333                        aNode.removeAllAddressTags();

  • applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/gui/SelectAddressesInMapAction.java

    r23933 r24091  
    3636import org.openstreetmap.josm.data.osm.OsmPrimitive;
    3737import org.openstreetmap.josm.plugins.fixAddresses.AddressEditContainer;
    38 import org.openstreetmap.josm.plugins.fixAddresses.AddressNode;
     38import org.openstreetmap.josm.plugins.fixAddresses.OSMAddress;
    3939
    4040/**
    … …  
    8787         * @param addrToSel
    8888         */
    89         private void internalSelectAddresses(List<AddressNode> addrToSel) {
     89        private void internalSelectAddresses(List<OSMAddress> addrToSel) {
    9090                if (addrToSel == null) return;
    9191               
    9292                List<OsmPrimitive> sel = new ArrayList<OsmPrimitive>();
    9393               
    94                 for (AddressNode aNode : addrToSel) {
     94                for (OSMAddress aNode : addrToSel) {
    9595                        sel.add(aNode.getOsmObject());
    9696                }

  • applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/gui/UnresolvedAddressesTableModel.java

    r24089 r24091  
    3232
    3333import org.openstreetmap.josm.plugins.fixAddresses.AddressEditContainer;
    34 import org.openstreetmap.josm.plugins.fixAddresses.AddressNode;
     34import org.openstreetmap.josm.plugins.fixAddresses.OSMAddress;
    3535import org.openstreetmap.josm.plugins.fixAddresses.IOSMEntity;
    3636import org.openstreetmap.josm.plugins.fixAddresses.StringUtils;
    … …  
    9696        @Override
    9797        public Object getValueAt(int row, int column) {
    98                 AddressNode aNode = (AddressNode) getEntityOfRow(row);
     98                OSMAddress aNode = (OSMAddress) getEntityOfRow(row);
    9999               
    100100                if (aNode == null) {
Note: See TracChangeset for help on using the changeset viewer.