Changeset 32274 in osm for applications/editors/josm

Timestamp:

2016-06-15T23:36:06+02:00 (8 years ago)

Author:

darya

Message:

Clarification

Location:

applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant

Files:

• actions/FixTask.java (added)
• validation/PTAssitantValidatorTest.java (modified) (9 diffs)
• validation/RouteChecker.java (modified) (8 diffs)

applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/validation/PTAssitantValidatorTest.java

@@ -20 +20 @@
 import org.openstreetmap.josm.data.validation.TestError;
 import org.openstreetmap.josm.gui.dialogs.relation.sort.RelationSorter;
+import org.openstreetmap.josm.plugins.pt_assistant.actions.FixTask;
 import org.openstreetmap.josm.plugins.pt_assistant.actions.IncompleteMembersDownloadThread;
 import org.openstreetmap.josm.plugins.pt_assistant.gui.IncompleteMembersDownloadDialog;
@@ -30 +31 @@
         public static final int ERROR_CODE_ROAD_TYPE = 3721;
         public static final int ERROR_CODE_DIRECTION = 3731;
-
+        
         public PTAssitantValidatorTest() {
                 super(tr("Public Transport Assistant tests"),
@@ -57 +58 @@
                 this.errors.addAll(wayChecker.getErrors());
 
-                if (!this.errors.isEmpty()) {
+                if (this.errors.isEmpty()) {
+                        proceedWithSorting(r);
+                } else {
                         this.proceedAfterWayCheckerErrors(r);
                 }
-
 
         }
@@ -116 +118 @@
 
                 if (userInput == 0) {
-                        for (TestError e : this.errors) {
-                                fixError(e);
-                        }
+                        this.fixErrorFromPlugin(this.errors);
                         proceedWithSorting(r);
                         return;
@@ -130 +130 @@
 
                 if (userInput == 2) {
+                        // TODO: should the errors be removed from the error list?
                         proceedWithSorting(r);
                 }
@@ -137 +138 @@
 
         }
-        
+
+        /**
+         * Carries out the second stage of the testing: sorting
+         * @param r
+         */
         private void proceedWithSorting(Relation r) {
+                
                 // Check if the relation is correct, or only has a wrong sorting order:
                 RouteChecker routeChecker = new RouteChecker(r, this);
-                this.errors.addAll(routeChecker.getErrors());
+                List<TestError> routeCheckerErrors = routeChecker.getErrors();
+                
+                /*- At this point, there are 3 variants: 
+                 * 
+                 * 1) There are no errors => route is correct
+                 * 2) There is only a sorting error (can only be 1), but otherwise
+                 * correct.
+                 * 3) There are some other errors/gaps that cannot be fixed by
+                 * sorting => start further test (stop-by-stop) 
+                 * 
+                 * */
+                
+                
+                if (!routeCheckerErrors.isEmpty()) {
+                        // Variant 2
+                        // If there is only the sorting error, add it and stop testing.
+                        this.errors.addAll(routeChecker.getErrors());
+                        return;
+                }
+                
+                if (!routeChecker.getHasGap()) {
+                        // Variant 1
+                        // TODO: add the segments of this route to the list correct route segments              
+                }
+                
+                // Variant 3:
+                proceedAfterSorting(r);
+                
+                
+        }
+        
+        
+        private void proceedAfterSorting(Relation r) {
+                // TODO
+                performDummyTest(r);
         }
 
@@ -158 +198 @@
         @Override
         public Command fixError(TestError testError) {
-                
-                List<Command> commands = new ArrayList<>(50);
-                
+
+                List<Command> commands = new ArrayList<>();
+
                 if (testError.getCode() == ERROR_CODE_DIRECTION || testError.getCode() == ERROR_CODE_ROAD_TYPE) {
                         commands.add(fixErrorByRemovingWay(testError));
                 }
-                
+
                 if (testError.getCode() == ERROR_CODE_SORTING) {
                         commands.add(fixSortingError(testError));
                 }
-                
+
                 if (commands.isEmpty()) {
                         return null;
@@ -180 +220 @@
         }
 
+        /**
+         * This method is the counterpart of the fixError(TestError testError)
+         * method. The fixError method is invoked from the core validator (e.g. when
+         * user presses the "Fix" button in the validator). This method is invoken
+         * when the fix is initiated from within the plugin (e.g. automated fixes).
+         * 
+         * @return
+         */
+        private void fixErrorFromPlugin(List<TestError> testErrors) {
+
+                        
+                        // run fix task asynchronously
+                        FixTask fixTask = new FixTask(testErrors);
+//                      Main.worker.submit(fixTask);
+                        
+                        Thread t = new Thread(fixTask);
+                        t.start();
+                        try {
+                                t.join();
+                                errors.removeAll(testErrors);
+
+                        } catch (InterruptedException e) {
+                                JOptionPane.showMessageDialog(null, "Error occurred during fixing");
+                        }
+
+
+
+        }
 
         private Command fixErrorByRemovingWay(TestError testError) {
-                
-        
+
                 if (testError.getCode() != ERROR_CODE_ROAD_TYPE && testError.getCode() != ERROR_CODE_DIRECTION) {
                         return null;
                 }
-                
+
                 List<OsmPrimitive> primitives = (List<OsmPrimitive>) testError.getPrimitives();
                 Relation originalRelation = (Relation) primitives.get(0);
@@ -236 +303 @@
                 ChangeCommand changeCommand = new ChangeCommand(originalRelation, modifiedRelation);
 
-                
                 return changeCommand;
         }

applications/editors/josm/plugins/pt_assistant/src/org/openstreetmap/josm/plugins/pt_assistant/validation/RouteChecker.java

@@ -5 +5 @@
 import java.util.ArrayList;
 import java.util.List;
+
+import javax.swing.JOptionPane;
 
 import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
@@ -24 +26 @@
         // relation that is checked:
         private Relation relation;
-        
+
         // stores all found errors (on way level):
         private ArrayList<TestError> errors = new ArrayList<>();
         
+        private boolean hasGap;
+
         List<RelationMember> sortedMembers;
 
@@ -35 +39 @@
                 this.relation = r;
                 
+                this.hasGap = false;
+
                 performSortingTest();
 
@@ -52 +58 @@
                         return;
                 }
-                
+
                 if (hasGap(waysToCheck)) {
+                        
+                        this.hasGap = true;
+                        
                         RelationSorter sorter = new RelationSorter();
                         sortedMembers = sorter.sortMembers(waysToCheck);
@@ -59 +68 @@
                         if (!hasGap(sortedMembers)) {
                                 TestError e = new TestError(this.test, Severity.WARNING,
-                                                tr("PT: Route contains a gap that can be fixed by sorting"), PTAssitantValidatorTest.ERROR_CODE_SORTING, relation);
+                                                tr("PT: Route contains a gap that can be fixed by sorting"),
+                                                PTAssitantValidatorTest.ERROR_CODE_SORTING, relation);
                                 this.errors.add(e);
 
@@ -65 +75 @@
 
                 }
-                
-                
 
         }
-        
+
         /**
          * Checks if there is a gap for a given list of ways. It does not check if
@@ -76 +84 @@
          * 
          * @param waysToCheck
-         * @return true if has gap (in the sense of continuity of ways in the Relation Editor), false otherwise
+         * @return true if has gap (in the sense of continuity of ways in the
+         *         Relation Editor), false otherwise
          */
         private boolean hasGap(List<RelationMember> waysToCheck) {
@@ -93 +102 @@
                 return false;
         }
-        
+
+        /**
+         * Returns errors
+         */
         public List<TestError> getErrors() {
 
                 return errors;
         }
+
+        public List<RelationMember> getSortedMembers() {
+
+                return sortedMembers;
+
+        }
         
-        public List<RelationMember> getSortedMembers() {
+        public boolean getHasGap() {
                 
-                return sortedMembers;
+                return this.hasGap;
                 
         }