This exception is used during download, extraction or + * parsing of the database. It can set a message to be displayed + * to the user by front-end components.
+ * + * @author Radomír Černcoh radomir.cernoch@gmail.com + * @see Database + * @see DatabaseParser + */ +public class DatabaseLoadException extends Exception { + + /** + * Default constructor, which sets the message description. + * @param message message to be shown to user + */ + public DatabaseLoadException(String message) { + super(message); + } +} Index: /applications/editors/josm/plugins/czechaddress/src/org/openstreetmap/josm/plugins/czechaddress/MapUtils.java =================================================================== --- /applications/editors/josm/plugins/czechaddress/src/org/openstreetmap/josm/plugins/czechaddress/MapUtils.java (revision 15166) +++ /applications/editors/josm/plugins/czechaddress/src/org/openstreetmap/josm/plugins/czechaddress/MapUtils.java (revision 15166) @@ -0,0 +1,81 @@ +package org.openstreetmap.josm.plugins.czechaddress; + +import java.util.Collection; +import org.openstreetmap.josm.Main; +import org.openstreetmap.josm.data.osm.Node; +import org.openstreetmap.josm.data.osm.OsmPrimitive; +import org.openstreetmap.josm.data.osm.Way; +import org.openstreetmap.josm.data.osm.visitor.BoundingXYVisitor; +import org.openstreetmap.josm.gui.MapView; + +/** + * Collection of utilities for manipulating the JOSM map. + * + *This set of state-less utilities, which can be handy in all parts of + * the plugin. Therefore all methods are {@code static} and the class is + * {@code abstract}.
+ * + * @author Radomír Černoch radomir.cernoch@gmail.com + */ +public abstract class MapUtils { + + static final double NODE_ZOOM_LEVEL = 0.00000007; + + + /** + * Selects and zooms the JOSM viewport to given primitives. + * + *It does so by calculating the center of given primitives and + * then it zooms to it.
+ * + *WARNING and TODO: The method {@code zoomTo()} currently + * checks for damaged {@link Node}s, whose {@code eastNorth} is set to + * null. This property is not accessed in this method and therefore + * no checking is done. However the "mad GUI" problem may still arise. + * Therefore please be careful.
+ * + * @see BoundingXYVisitor + * @see MapView + */ + public static void zoomToMany(CollectionTODO: There is an error in JOSM, which makes the whole + * GUI totally mad if we zoom to a {@link Node}, whose {@code eastNorth} + * is set null. Currently zooming to such a node is ignored, but the + * question is where so such damaged nodes come from?
+ * + * @see BoundingXYVisitor + * @see MapView + */ + public static void zoomTo(OsmPrimitive primitive) { + BoundingXYVisitor visitor = new BoundingXYVisitor(); + + if (primitive instanceof Node && ((Node) primitive).eastNorth != null) + Main.map.mapView.zoomTo(((Node) primitive).eastNorth, NODE_ZOOM_LEVEL); + + else if (primitive instanceof Way) { + ((Way) primitive).visit(visitor); + Main.map.mapView.zoomTo( + visitor.min.interpolate(visitor.max, 0.5), + NODE_ZOOM_LEVEL); + } + + Main.ds.setSelected(primitive); + } +} Index: /applications/editors/josm/plugins/czechaddress/src/org/openstreetmap/josm/plugins/czechaddress/NotNullList.java =================================================================== --- /applications/editors/josm/plugins/czechaddress/src/org/openstreetmap/josm/plugins/czechaddress/NotNullList.java (revision 15166) +++ /applications/editors/josm/plugins/czechaddress/src/org/openstreetmap/josm/plugins/czechaddress/NotNullList.java (revision 15166) @@ -0,0 +1,46 @@ +package org.openstreetmap.josm.plugins.czechaddress; + +import java.util.ArrayList; +import java.util.Collection; + +/** + * ArrayList, which refuses to add {@code null}. + * + * @author Radomír Černoch, radomir.cernoch@gmail.com + */ +public class NotNullListThere are several types of events in the plugin, which can happen during + * its lifetime. This interface is intended for classes that want to be + * aware of such changes.
+ * + *Currently there is one single class capable of broadcasting messages to + * {@link StatusListener}s, which is the {@link CzechAddressPlugin}. When anyone + * wants to notify all listeners about a change in the plugin's status, the + * {@link CzechAddressPlugin}{@code .broadcastStatusChanged()} method.
+ * + *For registering to the global broadcasting system, use + * {@link CzechAddressPlugin}{@code .addStatusListener()} or + * {@code removeStatusListener()}. + * + * @see CzechAddressPlugin + * + * @author Radomír Černoch, radomir.cernoch@gmail.com + */ +public interface StatusListener { + + /** + * The user's choice of location in the database has changed. + * + *
The new location can be obtained by + * {@link CzechAddressPlugin}{@code .getLocation()}.
+ * + * @see AddressElement + */ + static final int MESSAGE_LOCATION_CHANGED = 1; + + /** + * List of {@code matches} from the reasoner has changed. + * + *The current reasoner can be obtained by + * {@link CzechAddressPlugin}{@code .getReasoner()}.
+ * + * @see Reasoner + * @see Match + */ + static final int MESSAGE_MATCHES_CHANGED = 2; + + /** + * There is a new conflict spotted by the reasoner. + * + *The current reasoner can be obtained by + * {@link CzechAddressPlugin}{@code .getReasoner()}.
+ * + * @see Reasoner + * @see Match + */ + static final int MESSAGE_CONFLICT_CHANGED = 3; + + /** + * All parsers have finished their parsing. + * + *The current database can be obtained by + * {@link CzechAddressPlugin}{@code .getDatabase()}.
+ * + * @see CzechAddressPlugin + * @see DatabaseParser + * @see Database + */ + static final int MESSAGE_DATABASE_LOADED = 4; + + /** + * The reasoner has finished his reasoning. + * + *First such message also signalizes, that there is a reasoner + * available.
+ * + *The current reasoner can be obtained by + * {@link CzechAddressPlugin}{@code .getReasoner()}.
+ * + * @see Reasoner + */ + static final int MESSAGE_REASONER_REASONED = 5; + + /** + * Called when status of the plugin has changed. + * + *This method is called whenever someone calls + * {@link CzechAddressPlugin}{@code .broadcastStatusChanged()}.
+ * + *If you are implementing this interface and this method is not + * being called, make sure you registered to the messaging system by + * {@link CzechAddressPlugin}{@code .addStatusListener()}.
+ * + *Parameter {@code message} takes values from {@code MESSAGE_*} fields + * of this class. + * + * @param message the unique ID of the message + */ + void pluginStatusChanged(int message); +} Index: /applications/editors/josm/plugins/czechaddress/src/org/openstreetmap/josm/plugins/czechaddress/StringUtils.java =================================================================== --- /applications/editors/josm/plugins/czechaddress/src/org/openstreetmap/josm/plugins/czechaddress/StringUtils.java (revision 15166) +++ /applications/editors/josm/plugins/czechaddress/src/org/openstreetmap/josm/plugins/czechaddress/StringUtils.java (revision 15166) @@ -0,0 +1,32 @@ +package org.openstreetmap.josm.plugins.czechaddress; + +/** + * Collection of utilities for manipulating strings. + * + *
This set of state-less utilities, which can be handy in all parts of + * the plugin. Therefore all methods are {@code static} and the class is + * {@code abstract}.
+ * + * @author Radomír Černoch, radomir.cernoch@gmail.com + */ +public class StringUtils { + + /** + * Returns a substring equivalent to ^[0-9]* regexp match. + * + * @param s the input string + * @return ^[0-9]* substring match + */ + public static String extractNumber(String s) { + String result = ""; + for (int i=0; iNOTE: There should be only a single such window in the + * whole JOSM. Therefore the reference to the unique window is obtained + * from {@link CzechAddressPlugin}{@code .conflictResolver}. + */ + public void actionPerformed(ActionEvent e) { + if (CzechAddressPlugin.conflictResolver == null) return; + CzechAddressPlugin.conflictResolver.setVisible(true); + } +} Index: /applications/editors/josm/plugins/czechaddress/src/org/openstreetmap/josm/plugins/czechaddress/actions/FactoryAction.java =================================================================== --- /applications/editors/josm/plugins/czechaddress/src/org/openstreetmap/josm/plugins/czechaddress/actions/FactoryAction.java (revision 15166) +++ /applications/editors/josm/plugins/czechaddress/src/org/openstreetmap/josm/plugins/czechaddress/actions/FactoryAction.java (revision 15166) @@ -0,0 +1,111 @@ +package org.openstreetmap.josm.plugins.czechaddress.actions; + +import org.openstreetmap.josm.plugins.czechaddress.gui.FactoryDialog; +import java.awt.event.KeyEvent; +import java.awt.event.MouseEvent; +import java.awt.event.MouseListener; +import org.openstreetmap.josm.Main; +import org.openstreetmap.josm.actions.mapmode.MapMode; +import org.openstreetmap.josm.data.osm.Node; +import org.openstreetmap.josm.gui.MapFrame; +import org.openstreetmap.josm.plugins.czechaddress.CzechAddressPlugin; +import org.openstreetmap.josm.plugins.czechaddress.addressdatabase.House; +import org.openstreetmap.josm.plugins.czechaddress.intelligence.Reasoner; +import org.openstreetmap.josm.plugins.czechaddress.proposal.ProposalContainer; +import org.openstreetmap.josm.tools.ImageProvider; +import org.openstreetmap.josm.tools.Shortcut; + +/** + * Mapmode, which creates address elements with "one click". + * + *
This action takes the currently selected {@link House} from the + * {@link FactoryDialog} and creates a node for, whenever user clicks + * on the map.
+ * + * @see FactoryDialog + * + * @author Radomír Černoch, radomir.cernoch@gmail.com + */ +public class FactoryAction extends MapMode { + + /** + * Default constructor, which sets the title, shortcut, ... + */ + public FactoryAction(MapFrame frame) { + super("Sputit továrnu na adresy", + "envelope-cursor.png", + "Vytváří adresní body jedním kliknutím", + Shortcut.registerShortcut( "mapmode:clickaddress", + "Sputit továrnu na adresy", + KeyEvent.VK_F, Shortcut.GROUP_EDIT), + frame, + ImageProvider.getCursor("crosshair", "envelope-star-small")); + } + + /** + * Method called from JOSM when the user selects this mapmode. + * + *It registers itself into the {@link MapFrame}'s list of + * {@link MouseListener}s.
+ */ + @Override + public void enterMode() { + super.enterMode(); + Main.map.mapView.addMouseListener(this); + + Reasoner r = CzechAddressPlugin.getReasoner(); + + if (r == null) { + exitMode(); + return; + } + + FactoryDialog d = FactoryDialog.getInstance(); + if (r.translate(d.getSelectedHouse()) != null) + d.selectNextUnmatchedHouseByCheckBox(); + } + + /** + * Method called from JOSM when the user deselects this mapmode. + * + *It unregisters itself from the {@link MapFrame}'s list of + * {@link MouseListener}s.
+ */ + @Override + public void exitMode() { + Main.map.mapView.removeMouseListener(this); + super.exitMode(); + } + + /** + * Core methos of this action, which actually creates the nodes. + * + * @param e event encapsulating the click-position on the {@link MapFrame}. + */ + @Override + public void mouseClicked(MouseEvent e) { + super.mouseClicked(e); + + // Get the currently selected House in the FactoryDialog. + House house = FactoryDialog.getInstance().getSelectedHouse(); + if (house == null) + return; // TODO: Some meaningful messageBox would be useful. + + // Create a new Node and add it into the map. + Node newNode = new Node(Main.map.mapView.getLatLon(e.getX(), e.getY())); + + ProposalContainer container = new ProposalContainer(newNode); + container.setProposals(house.getDiff(newNode)); + container.applyAll(); + + // Notify reasoner about this newly added node. + CzechAddressPlugin.getReasoner().overwriteMatch(house, newNode); + + // And make the new node selected. + Main.ds.addPrimitive(newNode); + Main.ds.setSelected(newNode); + + // And do not forget to select next House in the list. + FactoryDialog.getInstance().selectNextUnmatchedHouseByCheckBox(); + } +} Index: /applications/editors/josm/plugins/czechaddress/src/org/openstreetmap/josm/plugins/czechaddress/actions/GroupManipulatorAction.java =================================================================== --- /applications/editors/josm/plugins/czechaddress/src/org/openstreetmap/josm/plugins/czechaddress/actions/GroupManipulatorAction.java (revision 15166) +++ /applications/editors/josm/plugins/czechaddress/src/org/openstreetmap/josm/plugins/czechaddress/actions/GroupManipulatorAction.java (revision 15166) @@ -0,0 +1,45 @@ +package org.openstreetmap.josm.plugins.czechaddress.actions; + +import org.openstreetmap.josm.plugins.czechaddress.gui.GroupManipulatorDialog; + +import java.awt.event.ActionEvent; +import java.awt.event.KeyEvent; + +import org.openstreetmap.josm.actions.JosmAction; +import org.openstreetmap.josm.plugins.czechaddress.CzechAddressPlugin; +import org.openstreetmap.josm.tools.Shortcut; + +/** + * Action adding a menu item for doing address completion. + * + * @see GroupManipulatorDialog + * + * @author Radomír Černoch radomir.cernoch@gmail.com + */ +public class GroupManipulatorAction extends JosmAction { + + /** + * Default constructor, which sets the title, shortcut, ... + */ + public GroupManipulatorAction() { + super("Přiřadit adresy", + "envelope-closed-big.png", + "Přiřadit adresy v celé stáhnuté oblasti", + Shortcut.registerShortcut("address:assignaddress", + "Adresy: Přiřadit adresy", + KeyEvent.VK_P, Shortcut.GROUP_DIRECT, Shortcut.SHIFT_DEFAULT), + true); + } + + /** + * Makes the {@link GroupManipulatorDialog} dialog visible. + * + *NOTE: This dialog assumes that the location has already been + * selected by the user. Therefore this action checks if the location is not + * {@code null}. If so, nothing happens.
+ */ + public void actionPerformed(ActionEvent e) { + if (CzechAddressPlugin.getLocation() == null) return; + GroupManipulatorDialog.getInstence().setVisible(true); + } +} Index: /applications/editors/josm/plugins/czechaddress/src/org/openstreetmap/josm/plugins/czechaddress/actions/PointManipulatorAction.java =================================================================== --- /applications/editors/josm/plugins/czechaddress/src/org/openstreetmap/josm/plugins/czechaddress/actions/PointManipulatorAction.java (revision 15166) +++ /applications/editors/josm/plugins/czechaddress/src/org/openstreetmap/josm/plugins/czechaddress/actions/PointManipulatorAction.java (revision 15166) @@ -0,0 +1,54 @@ +package org.openstreetmap.josm.plugins.czechaddress.actions; + +import java.awt.event.ActionEvent; +import java.awt.event.KeyEvent; +import java.util.Collection; +import org.openstreetmap.josm.Main; +import org.openstreetmap.josm.actions.JosmAction; +import org.openstreetmap.josm.data.osm.OsmPrimitive; +import org.openstreetmap.josm.plugins.czechaddress.CzechAddressPlugin; +import org.openstreetmap.josm.plugins.czechaddress.gui.PointManipulatorDialog; +import org.openstreetmap.josm.tools.Shortcut; + +/** + * Action adding a menu item for editing address points + * + * @see PointManipulatorDialog + * + * @author Radomír Černoch radomir.cernoch@gmail.com + */ +public class PointManipulatorAction extends JosmAction { + + /** + * Default constructor, which sets the title, shortcut, ... + */ + public PointManipulatorAction() { + super("Vytvořit/upravit adresu", + "envelope-open-star-big.png", + "Vytvoří nebo upraví adresní bod z čísla popisného.", + Shortcut.registerShortcut("tools:newaddress", + "Adresy: Vytvořit/upravit adres", + KeyEvent.VK_A, Shortcut.GROUP_DIRECT, Shortcut.SHIFT_DEFAULT), + true); + } + + /** + * Checks precoditions and eventually shows the dialog. + * + *This method checks, whether exactly one {@link OsmPrimitive} has been + * selected and whether the location was selected + * (the {@link PointManipulatorDialog} assumes a location is already + * selected. If both conditions are satisfied, dialog is opened.
+ */ + public void actionPerformed(ActionEvent e) { + CollectionTODO: The name is capitalized during the assignment, + * because the database contains all names IN CAPITALS. However + * this should not be done here, but in the {@link DatabaseParser}.
+ */ + public AddressElement (String name) { + if (name == null) + throw new NullPointerException("You must specify the name of this AddressElement"); + this.name = capitalize(name); + } + + /** + * Returns the name of this element. + * + *The name is returned "as it was entered" in the constructor.
+ */ + public String getName() { + return name; + } + + + public static String getName(Object o) { + if (o instanceof OsmPrimitive) + return getName((OsmPrimitive) o); + + if (o instanceof AddressElement) + return ((AddressElement) o).getName(); + + return null; + } + + public static String getName(OsmPrimitive prim) { + String cp = prim.get("addr:alternatenumber"); + String co = prim.get("addr:housenumber"); + String street = prim.get("addr:street"); + String city = prim.get("addr:city"); + String name = prim.get("name"); + + String result = ""; + + // Firstly we try to construct the name from name + place. + if (name != null) + result += name; + + // We prefer to display street. If not present, try city. + if (street != null) { + if (result.length() > 0) result += ", "; + result += street; + } else + if (city != null) { + if (result.length() > 0) result += ", "; + result += city; + } + + // If we can display CP, do it! + if (cp != null) { + if (result.length() > 0) result += " "; + result += cp; + } + + // If we can display CO, do it! + if (co != null) { + if (co != null) result += "/"; + result += co; + } + + if (prim instanceof Node) + result += " " + StringUtils.latLonToString(((Node) prim).coor); + else if (prim instanceof Way) + result += " " + StringUtils.latLonToString(((Way) prim).firstNode().coor); + + return result; + } + + /** + * Sets the new parent of this element. + * + *NOTE: Parent is NOT notified that this element has been + * assigned to him. This can be useful for some "ugly hacks".
+ */ + public void setParent(AddressElement parent) { + this.parent = parent; + } + + /** + * Returns the parent of this element. + * + * @return the parent element or {@code null} if no parent is present. + */ + public AddressElement getParent() { + return parent; + } + + /** + * Compares 2 elements. + * + *Basic criterion to comparing elements is their name and the + * parent. Notice that this behaviour might be changed + * in subclasses.
+ * + * @return {@code false} if name does not match, or parent + * does not match or {@code null} is given as a parameter. + * {@code true} otherwise. + */ + public boolean equals(AddressElement elem) { + if (elem == null) + return false; + else + return name.equals(elem.name) && this.parent == elem.parent; + } + + /** + * Returns the string representation of this element. + * + *If the parent of the element is {@code null}, then this equals + * to the element's name. Otherwise the result is created recursively + * as "name, parent.name".
+ */ + @Override + public String toString() { + return (parent == null) ? getName() : getName() + ", " + parent.toString(); + } + + + /** + * Capitalizes the given string (first letter of every word upper-case, + * others lower-case). Czech grammar rules are more or less obeyed. + * + *TODO: This should be moved somewhere else.
+ * + * @param s string to be capitalized + * @return capitaized string + */ + protected static String capitalize(String s) { + + if (s == null) + return s; + + String result = ""; + + char last = ' '; + for (char ch : s.toCharArray()) { + if ((last >= 'a') && (last <= 'ž') || + (last >= 'A') && (last <= 'Ž')) + ch = Character.toLowerCase(ch); + else + ch = Character.toTitleCase(ch); + + last = ch; + result = result + ch; + } + + String[] noCapitalize = { "Nad", "Pod", "U", "Na" }; + for (String noc : noCapitalize) + result = result.replaceAll(" "+noc+" ", " "+noc.toLowerCase()+" "); + + return result; + } + + /** + * Compute differences between two strings. + * + *Typical usage of this function is during {@code OsmPrimitive} to + * {@code AddressElement} matching. This function helps to whether the given + * field does match, does not or causes a conflict.
+ * + *This method returns {@code 1} if both fields do match, + * {@code 0} if they can be matched and {@code -1} if they do not match.
+ * + *Every house contains a number within the street + * (číslo orientační) or the number within the suburb (číslo popisné). + * Both numbers are stored as string to allow house numbers like '1a'.
+ * + *WARNING: Every house must have a parent, whose type is + * {@link ElementWithHouses}. The {@code setParent()} method should + * be called immediatelly after the constructor.
+ * + * @author Radomír Černoch, radomir.cernoch@gmail.com + */ +public class House extends AddressElement { + + /** Stores the number unique in a suburb (číslo popisné). */ + protected String cp = null; + /** Stores the number unique in a street (číslo orientační). */ + protected String co = null; + + /** + * Default constructor setting the numbers of this House. + * + * @param cp number unique in a suburb (číslo popisné) + * @param co number unique in a street (číslo orientační) + */ + public House(String cp, String co) { + // Firstly we pretend that this element has no name... + super(""); + + if (cp != null) this.cp = cp.toLowerCase(); + if (co != null) this.co = co.toLowerCase(); + + assert (co != null) || (cp != null); + + //... but the the name is overwritten. + this.name = generateName(this.cp, this.co); + } + + /** + * Returns the number unique in a suburb (číslo popisné) + */ + public String getCP() { + return cp; + } + + /** + * Returns the number unique in a street (číslo orientační) + */ + public String getCO() { + return co; + } + + /** + * Generates a name from house numbers. + * + *WARNING: Only one number can be {@link null}.
+ * + *If only one number is given, it is returned directly. If both numbers + * are given, they are combined in the way, which is standard in CZ.
+ * + * @param cp number unique in a suburb (číslo popisné) + * @param co number unique in a street (číslo orientační) + * @return string representation of a house with given house numbers. + */ + public static String generateName(String cp, String co) { + + if ((cp != null) && (co != null)) + return cp + "/" + co; + + if (co != null) return co; + if (cp != null) return cp; + + assert false; + return ""; // <-- just to make compiler happy. + } + + /** + * Returns the full name of this house (including street/suburb). + * + *WARNING: Every house must have a parent, whose type is + * {@link ElementWithHouses}. The {@code setParent()} method should + * be called immediatelly after the constructor.
+ */ + @Override + public String getName() { + assert parent != null : "A house must always have a parent."; + return parent.getName() + " " + name; + } + + /** + * Sets the parent of this house with type-checking. + * + *WARNING: Every house must have a parent, whose type is + * {@link ElementWithHouses}. The {@code setParent()} method should + * be called immediatelly after the constructor.
+ */ + @Override + public void setParent(AddressElement parent) { + assert parent instanceof ElementWithHouses; + super.setParent(parent); + } + + /** + * Returns the parent of this house with type-checking. + * + *WARNING: Every house must have a parent, whose type is + * {@link ElementWithHouses}. The {@code setParent()} method should + * be called immediatelly after the constructor.
+ */ + @Override + public ElementWithHouses getParent() { + assert parent instanceof ElementWithHouses; + return (ElementWithHouses) parent; + } + + /** + * Returns an array describing how the house fits to given primitive. + * + *Values of the array are described in + * {@link AddressElement}{@code .getFieldMatchList()}.
+ * + *First elemtn of the returned array corresponds to the CP + * (číslo popisné), the second one to the combination of Street+CO.
+ */ + @Override + protected int[] getFieldMatchList(OsmPrimitive prim) { + int[] result = {0, 0}; + + // First field is the AlternateNubmer + result[0] = matchField(this.cp, prim.get(KEY_ADDR_CP)); + + // Second field is the Housenumber + if (parent instanceof Street) + result[1] = Math.min( matchField(parent.getName(), prim.get(KEY_ADDR_STREET)), + matchField(this.co, prim.get(KEY_ADDR_CO)) ); + return result; + } + + /** + * Gives all proposals to make the primitive be an address primitive. + * + *Tries to fill {@code prim}'s attributes to have all attributes that + * this House has.
+ */ + @Override + public ListWARNING: Do NOT modify this code. The content of this method is + * always regenerated by the Netbeans Form Editor.
+ */ + @SuppressWarnings("unchecked") + //This creates a list of {@link ListDataListener}s and implements + * method for adding and removing them. Moreover it allows to notify all + * listeners with the generic message {@code CONTENT_CHANGED}.
+ * + * @author Radomír Černoch, radomir.cernoch@gmail.com + */ +public abstract class HalfCookedComboBoxModel implements ComboBoxModel { + + ListThis creates a list of {@link ListDataListener}s and implements + * method for adding and removing them. Moreover it allows to notify all + * listeners with the generic message {@code CONTENT_CHANGED}.
+ * + * @author Radomír Černoch, radomir.cernoch@gmail.com + */ +public abstract class HalfCookedListModel implements ListModel { + + ListThis creates a list of {@link TreeModelListener}s and implements + * method for adding and removing them. Moreover it allows to notify all + * listeners with the generic message telling that the whole tree + * has changed.
+ * + * @author Radomír Černoch, radomir.cernoch@gmail.com + */ +public abstract class HalfCookedTreeModel implements TreeModel { + + ListWARNING: Do NOT modify this code. The content of this method is + * always regenerated by the Form Editor.
+ */ + @SuppressWarnings("unchecked") + //HouseReasoner holds the relations between House and OsmPrimitive + * and also tries to keep it consistent with the state of the map. + * Firstly it is initialised by {@code initReasoner()} and subsequently and + * change done to the map should be reflected in HouseReasoner by calling + * {@code addPrimitive} or {@code removePrimitive}.
+ * + *NOTE: Currently there is no known way of adding a hook into JOSM + * to detect changed or deleted elements. Therefore every call of + * {@code ensureConsistency()} checks for deleted elements, which is rather + * inefficient. Moreover there is a listener for selectionChanged, which + * checks deselcted items for their change. Again, inefficient.
+ * + * @author Radomír Černoch radomir.cernoch@gmail.com + */ +public class Reasoner { + + /** A database of all matches, which are not in a conflict. */ + private NotNullListIf you intend to add a list of new primitives, {@link addPrimitives} + * will be faster, because conflicts are traced after adding all the + * primitives and not after every single one.
+ * + *Moreover there is one substantial difference discussed in + * {@link addPrimitives()}.
+ * + * @param newPrimitive new primitive to be added + */ + public synchronized void addPrimitive(OsmPrimitive newPrimitive) { + + int firstNewIndex = matches.size(); + + matchPrimitive(newPrimitive); + + ensureConsistency(firstNewIndex); + } + + /** + * Adds new primitives to the database, finds suitable {@link House}s for + * them and afterwards seeks for potential conflicts. + * + *NOTE: Adding primitives through {@code addPrimitives()} has + * different effect from adding primitives one by one through + * {@code addPrimitive()}.
+ * + *The preffered way of handling this is to add a large bunch of elements + * from the database via {@code addPrimitives()}, because the possible + * conflicts are between all possible element-primitive combinations. + * For adding single node by user, {@code addPrimitives()} is the preferred + * way, because immediatelly after the matching the best suitable element + * is removed from the element pool and it cannot be matched to any other + * primitive.
+ */ + public synchronized void addPrimitives(CollectionThis can be useful in cases, where the user manually resolves + * a conflict by stating that this particular combination of + * house-primitive it the correct one.
+ * + *The quality is set to {@link Match}{@code .MATCH_OVERWRITE}.
+ */ + public synchronized void overwriteMatch(AddressElement elem, OsmPrimitive prim) { + + int firstNewIndex = matches.size(); + + matches.add(new Match(elem, prim, Match.MATCH_OVERWRITE)); + matchesDirty = true; + + reconsider(elem); + reconsider(prim); + + ensureConsistency(firstNewIndex); + } + + /** + * Returns all elements available for matching. + */ + public ListIf the primitive is not found, {@code null} is returned.
+ */ + public AddressElement translate(OsmPrimitive prim) { + Match m = primMatchHashIndex.get(prim); + if (m == null) return null; + return m.elem; + } + + /** + * Finds given element in list of {@code matches} and returns the corresponding + * primitive. + * + *If the element is not found, {@code null} is returned.
+ */ + public OsmPrimitive translate(AddressElement elem) { + Match m = elemMatchHashIndex.get(elem); + if (m == null) return null; + return m.prim; + } + + /** + * Returns a list all conflicts corresponding to the given {@link AddressElement}. + */ + public ListThis method uses {@code getMatchesForPrimitive()} for getting the
+ * list of suitable matches for the given primitive. Then it selects
+ * all matches with the highest {@code quality} and adds them
+ * into the {@code matches} list.
+ */
+ protected void matchPrimitive(OsmPrimitive prim) {
+ boolean assertions = false;
+ assert assertions = true;
+
+ if (prim.deleted) return;
+
+ NotNullList If the {@code matchesDirty} or {@code conflictsDirty} flag is
+ * {@link true}, this method informs all listeners about the change
+ * of plugin's status. This method should be called at the end of every public method,
+ * which changes anything in the reasoner. This method should be called at the end of every public method,
+ * which changes anything in the reasoner. Checking every match with every match is computationally inefficient.
+ * Therefore by specifying {@code startElementIndex > 0}, we can
+ * reduce this cost by checking every match with every match,
+ * whose index is greater than {@code startElementIndex}. If a primitive has been deleted, the first immediate action is to
+ * remove it from the {@code matches} and {@code conflicts} lists.
+ * However there might be another conflict, which was caused by the
+ * deleted primitive. This method finds such conflicts and
+ * moves them back to {@code matches} list to
+ * be reconsideres later. Slower, but safer counterpart of {@code handleDeletedPrimitives))}. Currently JOSM has no way of giving notice about a changed or deleted
+ * node. This class tries to overcome this at the cost of computational
+ * inefficiency. It monitors every de-selected primitive. This class has is capable of initialising the parser and handling errors,
+ * but parsing the actual document must be done by subclasses. If no container with the given primitive is found, null is returned.
+ * If there are multiple containers (which should not be the case),
+ * the first is returned. If the primitive is already in the database, the proposal
+ * is added to its container. If not, a new container is created. Methods from this class are typically called from
+ * {@link AddressElement}{@code .getDiff()} when the user wants to copy
+ * attributes from an {@code AddressElement} to {@link OsmPrimitive}.
+ *
+ * @author Radomír Černoch, radomir.cernoch@gmail.com
+ */
+public abstract class ProposalFactory {
+
+ /**
+ * Unifies two strings to create a perfect match.
+ *
+ * @param key name of the attribute (eg. highway); not used when matching,
+ * just passed to newly created {@link Proposal} to inform the user
+ * @param current original value of the attribute (eg. residental);
+ * usually the current value of some {@link OsmPrimitive}'s attribute
+ * @param target the target value of the attribute (eg. service);
+ * usually the value of some {@link AddressElement}.
+ * @return the {@link Proposal}, whose application unifies current
+ * and target
+ */
+ public static Proposal getStringFieldDiff(
+ String key, String current, String target) {
+
+ if (target == null) {
+ if (current != null)
+ return new RemoveKeyProposal(key);
+ else
+ return null;
+ }
+
+ if (current == null)
+ return new AddKeyValueProposal(key, target);
+
+ if (!current.toUpperCase().equals(target.toUpperCase()))
+ return new KeyValueChangeProposal(
+ key, current,
+ key, target);
+
+ return null;
+ }
+
+ /**
+ * Makes the {@code current} string contain the {@code target}.
+ *
+ * Some attributes consist of several values, which are delimited
+ * by , or ;. This checks if current list contains
+ * such a value and if not, it's added.