();
-
- for (AddressElement elem : elemPool)
- result.add(Match.createMatch(elem, primitive));
- return result;
- }
-
- /**
- * Method for adding matches for a single primitive into the resoner.
- *
- * This 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 suitable = getMatchesForPrimitive(prim);
- NotNullList toDelete = new NotNullList(suitable.size());
-
- for (Match match1 : suitable)
- for (Match match2 : suitable)
- if ( match1 != match2
- && match1.quality > match2.quality) {
- toDelete.add(match2);
- if (assertions)
- System.out.println("Reasoner: Dominated match: " + match2.toString());
- }
-
- suitable.removeAll(toDelete);
-
- // Make sure we reconsider all elements.
- for (Match match : matches) {
- reconsider(match.elem);
- reconsider(match.prim);
- }
-
- if (suitable.size() > 0) {
- matches.addAll(suitable);
- matchesDirty = true;
- } else
- notMatchable.add(prim);
- }
-
-//==============================================================================
-// MESSAGE HANDLING SYSTEM
-//==============================================================================
-
- /**
- * Should be true whenever {@code matches} have changed, but the
- * {@link StatusListener}{@code .MESSAGE_MATCHES_CHANGED} message has
- * not yet been sent.
- */
- protected boolean matchesDirty = false;
-
- /**
- * Should be true whenever {@code conflicts} have changed, but the
- * {@link StatusListener}{@code .MESSAGE_CONFLICT_CHANGED} message has
- * not yet been sent.
- */
- protected boolean conflictsDirty = false;
-
- /**
- * Broadcasts information about the changes of reasoner status.
- *
- * If the {@code matchesDirty} or {@code conflictsDirty} flag is
- * {@link true}, this method informs all listeners about the change
- * of plugin's status.
- */
- protected void handleDirt() {
-
- if (matchesDirty || conflictsDirty)
- regenerateIndexes();
-
- if (matchesDirty) CzechAddressPlugin.broadcastStatusChanged(
- StatusListener.MESSAGE_MATCHES_CHANGED);
-
- if (conflictsDirty) CzechAddressPlugin.broadcastStatusChanged(
- StatusListener.MESSAGE_CONFLICT_CHANGED);
-
- matchesDirty = conflictsDirty = false;
- }
-
-//==============================================================================
-// CONSISTENCY CHECKING
-//==============================================================================
-
- /**
- * Should be called after modifying anything to put reasoner into
- * consistent state.
- *
- * This method should be called at the end of every public method,
- * which changes anything in the reasoner.
- */
- public void ensureConsistency() {
- ensureConsistency(0);
- }
-
- /**
- * Should be called after modifying anything to put reasoner into
- * consistent state.
- *
- * 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}.
- */
- public void ensureConsistency(int startElementIndex) {
- startElementIndex = 0;
-
- NotNullList toDel = new NotNullList(10);
- for (Match match1 : matches) for (Match match2 : matches) {
-
- if (match1 == match2) continue;
-
- if (match1.prim == match2.prim && match1.quality > match2.quality) {
- System.out.println("Reasoner: Redundancy clean: " + match2);
- toDel.add(match2);
- matchesDirty = true;
- }
-
- if (match1.prim == match2.prim && match1.quality >= match2.quality
- && match1.elem == match2.elem && !toDel.contains(match1)) {
- System.out.println("Reasoner: Hyper redundancy: " + match2);
- toDel.add(match2);
- matchesDirty = true;
- }
- }
- matches.removeAll(toDel);
-
- toDel.clear();
- for (Match conflict1 : conflicts) for (Match conflict2 : conflicts) {
-
- if (conflict1 == conflict2) continue;
-
- if (conflict1.prim == conflict2.prim
- && conflict1.elem == conflict2.elem && !toDel.contains(conflict1)) {
- System.out.println("Reasoner: Confl redundancy: " + conflict2);
- toDel.add(conflict2);
- conflictsDirty = true;
- }
- }
- conflicts.removeAll(toDel);
-
- for (Match match : matches)
- for (Match conflict : conflicts) {
- assert match != conflict;
- assert match.prim != conflict.prim;
- }
-
-
-
- if (handleDeletedPrimitivesSlowButSafe())
- startElementIndex = 0;
- handleInconsistentMatches(startElementIndex);
- handleDirt();
-
- CzechAddressPlugin.broadcastStatusChanged(
- StatusListener.MESSAGE_REASONER_REASONED);
- }
-
- /**
- * Finds conflicts in the {@code matches} list and moves them to
- * {@code conflicts} list.
- */
- protected void handleInconsistentMatches(int startElementIndex) {
- boolean assertions = false;
- assert assertions = true;
-
-
- // Move all conflicting matches into 'conflicts' array.
- int pos1 = 0;
- while (pos1 < matches.size()) {
-
- int pos2 = Math.max(pos1 + 1, startElementIndex);
- while (pos2 < matches.size()) {
-
- Match item1 = matches.get(pos1);
- Match item2 = matches.get(pos2);
-
- if ((item1.elem == item2.elem) || (item1.prim == item2.prim)) {
-
- if (assertions) {
- System.out.println("1. match in conflict: " + item2);
- System.out.println("2. match in conflict: " + item1);
- }
-
- if (item1.quality >= item2.quality) {
- if (assertions)
- System.out.println("1. match moved to 'conflicts'.");
- matches.remove(pos2);
- conflicts.add(item2);
- matchesDirty = conflictsDirty = true;
- pos2--;
- }
-
- if (item1.quality <= item2.quality) {
- if (assertions) {
- System.out.println("2. match moved to 'conflicts'.");
- System.out.println("----------------------------------------------------------------------");
- }
- matches.remove(pos1);
- conflicts.add(item1);
- matchesDirty = conflictsDirty = true;
- pos1--;
- break;
- }
-
- if (assertions)
- System.out.println("----------------------------------------------------------------------");
- }
-
- pos2++;
- }
- pos1++;
- }
- }
-
- /**
- * Seeks and handles primitives, which have been deleted.
- *
- * 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.
- */
- protected boolean handleDeletedPrimitives() {
-
- boolean somethingChanged = false;
- NotNullList blockers = new NotNullList();
-
- // Firstly create a list of all primitives, which were deleted.
- for (Match match : matches)
- if (match.prim.deleted)
- blockers.add(match.prim);
-
- for (Match conflict : conflicts)
- if (conflict.prim.deleted)
- blockers.add(conflict.prim);
-
- // Now for every deleted primitive...
- int i=0;
- while (i < blockers.size()) {
- OsmPrimitive blocker = blockers.get(i);
-
- // ... remove its' entries in the 'matches' ...
- if (primMatchHashIndex.get(blocker) != null) {
- Match toRemove = primMatchHashIndex.get(blocker);
- matches.remove(toRemove);
- primMatchHashIndex.remove(toRemove.prim);
- elemMatchHashIndex.remove(toRemove.elem);
- somethingChanged = matchesDirty = true;
- }
-
- // ... and reconsider all 'conflicts', which may have been caused
- // by the deleted primitive. We must do it recursively...
-
- // Every conflict, which has the 'blocker' as a primitive
- if (primConflictHashIndex.get(blocker) != null) {
- for (Match match : primConflictHashIndex.get(blocker)) {
- // Find the correspoding element and find all primitives,
- // which are mapped to this element.
- if (elemConflictHashIndex.get(match.elem) != null) {
- for (Match novy : elemConflictHashIndex.get(match.elem)) {
- // If this primitive has not yet been handled, do it!
- if (!blockers.contains(novy.prim))
- blockers.add(novy.prim);
- // And move the conflict back to 'matches' for reconsideration.
- if (!novy.prim.deleted && !matches.contains(novy)) {
- matches.add(novy);
- somethingChanged = matchesDirty = true;
- }
- }
- // Finally remove the reconsidered conflicts...
- conflicts.removeAll(elemConflictHashIndex.get(match.elem));
- elemConflictHashIndex.remove(match.elem);
- elemConflictListIndex.remove(match.elem);
- somethingChanged = conflictsDirty = true;
- }
- // [move the conflict back to 'matches' for reconsideration]
- if (!match.prim.deleted && !matches.contains(match)) {
- matches.add(match);
- somethingChanged = matchesDirty = true;
- }
- }
- // ...and once again remove reconsidered conflicts.
- conflicts.removeAll(primConflictHashIndex.get(blocker));
- primConflictHashIndex.remove(blocker);
- primConflictListIndex.remove(blocker);
- somethingChanged = conflictsDirty = true;
- }
- i++;
- }
-
- return somethingChanged;
- }
-
- /**
- * Seeks and handles primitives, which have been deleted.
- *
- * Slower, but safer counterpart of {@code handleDeletedPrimitives))}.
- */
- protected boolean handleDeletedPrimitivesSlowButSafe() {
-
- boolean fire = false;
-
- for (Match match : matches)
- fire |= match.qualityChanged();
-
- for (Match conflict : conflicts)
- fire |= conflict.qualityChanged();
-
- if (fire) {
- matches.addAll(conflicts);
- conflicts.clear();
- matchesDirty = conflictsDirty = true;
-
- int i=0;
- while (i reconsider;
-
- reconsider = getConflicts(prim);
- if (reconsider != null) {
- matches.addAll(reconsider);
- conflicts.removeAll(reconsider);
- matchesDirty = conflictsDirty = true;
- }
- }
-
- protected void reconsider(AddressElement elem) {
-
- List reconsider;
-
- reconsider = getConflicts(elem);
- if (reconsider != null) {
- matches.addAll(reconsider);
- conflicts.removeAll(reconsider);
- matchesDirty = conflictsDirty = true;
- }
- }
-
- /**
- * Recreates all {@code *Index} fields if this reasoner.
- */
- protected void regenerateIndexes() {
- boolean assertions = false;
- assert assertions = true;
-
- elemMatchHashIndex.clear();
- primMatchHashIndex.clear();
- elemConflictHashIndex.clear();
- primConflictHashIndex.clear();
- elemConflictListIndex.clear();
- primConflictListIndex.clear();
-
- for (Match match : matches) {
- elemMatchHashIndex.put(match.elem, match);
- primMatchHashIndex.put(match.prim, match);
- }
-
- for (Match conflict : conflicts) {
-
- List elemConflicts = elemConflictHashIndex.get(conflict.elem);
- if (elemConflicts == null) {
- elemConflicts = new ArrayList();
- elemConflictHashIndex.put(conflict.elem, elemConflicts);
- }
- elemConflicts.add(conflict);
-
- List primConflicts = primConflictHashIndex.get(conflict.prim);
- if (primConflicts == null) {
- primConflicts = new ArrayList();
- primConflictHashIndex.put(conflict.prim, primConflicts);
- }
- primConflicts.add(conflict);
- }
-
- for (AddressElement elem : elemConflictHashIndex.keySet())
- elemConflictListIndex.add(elem);
-
- for (OsmPrimitive prim : primConflictHashIndex.keySet())
- primConflictListIndex.add(prim);
-
- assert elemConflictHashIndex.size() == elemConflictListIndex.size();
- assert primConflictHashIndex.size() == primConflictListIndex.size();
-
- for (AddressElement elem : elemConflictListIndex)
- assert elemConflictHashIndex.get(elem) != null;
- for (OsmPrimitive prim : primConflictListIndex)
- assert primConflictHashIndex.get(prim) != null;
-
- if (assertions) {
- System.out.println("Spárovaných dvojic: " + String.valueOf(matches.size()));
- System.out.println("Konfliktů (celkem): " + String.valueOf(conflicts.size())
- + "; " + String.valueOf(elemConflictListIndex.size())
- + "+" + String.valueOf(primConflictListIndex.size())
- + " elementů+primitiv");
+ Node n1 = new Node(1);
+ n1.put("addr:street", "Jarní");
+ n1.put("addr:alternatenumber", "242");
+
+ r.openTransaction();
+ r.consider(n1);
+ r.closeTransaction();
+ assert r.translate(n1) == h4;
+ assert r.conflicts(n1).size() == 0;
+
+
+
+ Node n2 = new Node(2);
+ n2.put("addr:alternatenumber", "240");
+ r.openTransaction();
+ r.consider(n2);
+ r.closeTransaction();
+ assert r.translate(n2) == null;
+ assert r.conflicts(n2).contains(h1);
+ assert r.conflicts(n2).contains(i4);
+
+ n2.put("addr:street", "Letní");
+ n2.put("addr:housenumber", "4");
+ r.openTransaction();
+ r.consider(n2);
+ r.closeTransaction();
+ assert r.translate(n2) == i4;
+ assert r.conflicts(n2).contains(h1);
+
+
+ n2.deleted = true;
+ r.openTransaction();
+ r.consider(n2);
+ r.closeTransaction();
+
+ assert r.translate(n2) == null;
+
+ } catch (Exception ex) {
+
+ ex.printStackTrace();
}
}
Index: applications/editors/josm/plugins/czechaddress/src/org/openstreetmap/josm/plugins/czechaddress/parser/MvcrParser.java
===================================================================
--- applications/editors/josm/plugins/czechaddress/src/org/openstreetmap/josm/plugins/czechaddress/parser/MvcrParser.java (revision 15412)
+++ applications/editors/josm/plugins/czechaddress/src/org/openstreetmap/josm/plugins/czechaddress/parser/MvcrParser.java (revision 15461)
@@ -1,5 +1,6 @@
package org.openstreetmap.josm.plugins.czechaddress.parser;
-import org.openstreetmap.josm.plugins.czechaddress.addressdatabase.*;
+import static org.openstreetmap.josm.plugins.czechaddress.StringUtils.capitalize;
+
import java.io.FileInputStream;
import java.io.IOException;
@@ -7,8 +8,13 @@
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
-
-
import org.openstreetmap.josm.Main;
import org.openstreetmap.josm.plugins.czechaddress.DatabaseLoadException;
+import org.openstreetmap.josm.plugins.czechaddress.addressdatabase.ElementWithHouses;
+import org.openstreetmap.josm.plugins.czechaddress.addressdatabase.ElementWithStreets;
+import org.openstreetmap.josm.plugins.czechaddress.addressdatabase.House;
+import org.openstreetmap.josm.plugins.czechaddress.addressdatabase.Region;
+import org.openstreetmap.josm.plugins.czechaddress.addressdatabase.Street;
+import org.openstreetmap.josm.plugins.czechaddress.addressdatabase.Suburb;
+import org.openstreetmap.josm.plugins.czechaddress.addressdatabase.ViToCi;
import org.xml.sax.Attributes;
import org.xml.sax.Locator;
@@ -48,7 +54,7 @@
if (curRegion == null) {*/
curRegion = new Region(
- attributes.getValue("nazev"),
- attributes.getValue("kraj"),
- attributes.getValue("okres"));
+ capitalize(attributes.getValue("nazev")),
+ capitalize(attributes.getValue("kraj")),
+ capitalize(attributes.getValue("okres")));
target.regions.add(curRegion);
@@ -60,5 +66,5 @@
return;
- // ========== PARSING ViToCI ========== //
+ // ========== PARSING ViToCi ========== //
if (name.equals("obec")) {
@@ -69,5 +75,5 @@
//curViToCi = curRegion.findViToCi(attributes.getValue("nazev"));
//if (curViToCi == null) {
- curViToCi = new ViToCi(attributes.getValue("nazev"));
+ curViToCi = new ViToCi(capitalize(attributes.getValue("nazev")));
// System.out.println("Parser: " + curViToCi);
curRegion.addViToCi(curViToCi);
@@ -86,5 +92,5 @@
//curSuburb = curViToCi.findSuburb(attributes.getValue("nazev"));
//if (curSuburb == null) {
- curSuburb = new Suburb(attributes.getValue("nazev"));
+ curSuburb = new Suburb(capitalize(attributes.getValue("nazev")));
// System.out.println("Parser: " + curSuburb);
curViToCi.addSuburb(curSuburb);
@@ -105,5 +111,5 @@
//curStreet = topElem.findStreet(attributes.getValue("nazev"));
//if (curStreet == null) {
- curStreet = new Street(attributes.getValue("nazev"));
+ curStreet = new Street(capitalize(attributes.getValue("nazev")));
// System.out.println("Parser: " + curStreet);
topElem.addStreet(curStreet);