Changeset 10129 in josm


Ignore:
Timestamp:
2016-04-09T23:24:01+02:00 (3 years ago)
Author:
Don-vip
Message:

refactor duplicated code

Location:
trunk/src/org/openstreetmap/josm
Files:
1 added
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/org/openstreetmap/josm/actions/downloadtasks/AbstractChangesetDownloadTask.java

    r10124 r10129  
    33
    44import java.awt.Component;
     5import java.lang.reflect.InvocationTargetException;
    56import java.net.URL;
    67import java.util.HashSet;
     
    89import java.util.concurrent.Future;
    910
     11import javax.swing.SwingUtilities;
     12
    1013import org.openstreetmap.josm.Main;
    1114import org.openstreetmap.josm.data.Bounds;
    1215import org.openstreetmap.josm.data.osm.Changeset;
     16import org.openstreetmap.josm.data.osm.ChangesetCache;
    1317import org.openstreetmap.josm.gui.PleaseWaitRunnable;
    1418import org.openstreetmap.josm.gui.progress.ProgressMonitor;
    1519import org.openstreetmap.josm.io.OsmServerChangesetReader;
     20import org.openstreetmap.josm.tools.ExceptionUtil;
     21import org.openstreetmap.josm.tools.bugreport.BugReportExceptionHandler;
    1622
    1723/**
     
    4652            lastException = e;
    4753            setFailed(true);
     54        }
     55
     56        protected final void updateChangesets() {
     57            // update the global changeset cache with the downloaded changesets.
     58            // this will trigger change events which views are listening to. They
     59            // will update their views accordingly.
     60            //
     61            // Run on the EDT because UI updates are triggered.
     62            //
     63            Runnable r = new Runnable() {
     64                @Override public void run() {
     65                    ChangesetCache.getInstance().update(downloadedChangesets);
     66                }
     67            };
     68            if (SwingUtilities.isEventDispatchThread()) {
     69                r.run();
     70            } else {
     71                try {
     72                    SwingUtilities.invokeAndWait(r);
     73                } catch (InterruptedException e) {
     74                    Main.warn("InterruptedException in "+getClass().getSimpleName()+" while updating changeset cache");
     75                } catch (InvocationTargetException e) {
     76                    Throwable t = e.getTargetException();
     77                    if (t instanceof RuntimeException) {
     78                        BugReportExceptionHandler.handleException(t);
     79                    } else if (t instanceof Exception) {
     80                        ExceptionUtil.explainException(e);
     81                    } else {
     82                        BugReportExceptionHandler.handleException(t);
     83                    }
     84                }
     85            }
    4886        }
    4987    }
  • trunk/src/org/openstreetmap/josm/actions/downloadtasks/ChangesetHeaderDownloadTask.java

    r10124 r10129  
    66import java.awt.Component;
    77import java.io.IOException;
    8 import java.lang.reflect.InvocationTargetException;
    98import java.util.Collection;
    109import java.util.Collections;
    1110import java.util.HashSet;
    1211import java.util.Set;
    13 
    14 import javax.swing.SwingUtilities;
    1512
    1613import org.openstreetmap.josm.Main;
     
    2017import org.openstreetmap.josm.io.OsmTransferException;
    2118import org.openstreetmap.josm.tools.CheckParameterUtil;
    22 import org.openstreetmap.josm.tools.ExceptionUtil;
    23 import org.openstreetmap.josm.tools.bugreport.BugReportExceptionHandler;
    2419import org.xml.sax.SAXException;
    2520
     
    7469                ExceptionDialogUtil.explainException(lastException);
    7570            }
    76             Runnable r = new Runnable() {
    77                 @Override
    78                 public void run() {
    79                     ChangesetCache.getInstance().update(downloadedChangesets);
    80                 }
    81             };
    82 
    83             if (SwingUtilities.isEventDispatchThread()) {
    84                 r.run();
    85             } else {
    86                 try {
    87                     SwingUtilities.invokeAndWait(r);
    88                 } catch (InterruptedException e) {
    89                     Main.warn("InterruptedException in "+getClass().getSimpleName()+" while updating changeset cache");
    90                 } catch (InvocationTargetException e) {
    91                     Throwable t = e.getTargetException();
    92                     if (t instanceof RuntimeException) {
    93                         BugReportExceptionHandler.handleException(t);
    94                     } else if (t instanceof Exception) {
    95                         ExceptionUtil.explainException(e);
    96                     } else {
    97                         BugReportExceptionHandler.handleException(t);
    98                     }
    99                 }
    100             }
     71            updateChangesets();
    10172        }
    10273    }
  • trunk/src/org/openstreetmap/josm/actions/downloadtasks/ChangesetQueryTask.java

    r10124 r10129  
    66import java.awt.Component;
    77import java.io.IOException;
    8 import java.lang.reflect.InvocationTargetException;
    98
    109import javax.swing.JOptionPane;
    11 import javax.swing.SwingUtilities;
    1210
    1311import org.openstreetmap.josm.Main;
    14 import org.openstreetmap.josm.data.osm.ChangesetCache;
    1512import org.openstreetmap.josm.data.osm.UserInfo;
    1613import org.openstreetmap.josm.gui.JosmUserIdentityManager;
     
    2219import org.openstreetmap.josm.tools.CheckParameterUtil;
    2320import org.openstreetmap.josm.tools.ExceptionUtil;
    24 import org.openstreetmap.josm.tools.bugreport.BugReportExceptionHandler;
    2521import org.xml.sax.SAXException;
    2622
     
    10399                return;
    104100            }
    105 
    106             // update the global changeset cache with the downloaded changesets.
    107             // this will trigger change events which views are listening to. They
    108             // will update their views accordingly.
    109             //
    110             // Run on the EDT because UI updates are triggered.
    111             //
    112             Runnable r = new Runnable() {
    113                 @Override public void run() {
    114                     ChangesetCache.getInstance().update(downloadedChangesets);
    115                 }
    116             };
    117             if (SwingUtilities.isEventDispatchThread()) {
    118                 r.run();
    119             } else {
    120                 try {
    121                     SwingUtilities.invokeAndWait(r);
    122                 } catch (InterruptedException e) {
    123                     Main.warn("InterruptedException in "+getClass().getSimpleName()+" while updating changeset cache");
    124                 } catch (InvocationTargetException e) {
    125                     Throwable t = e.getTargetException();
    126                     if (t instanceof RuntimeException) {
    127                         BugReportExceptionHandler.handleException(t);
    128                     } else if (t instanceof Exception) {
    129                         ExceptionUtil.explainException(e);
    130                     } else {
    131                         BugReportExceptionHandler.handleException(t);
    132                     }
    133                 }
    134             }
     101            updateChangesets();
    135102        }
    136103
  • trunk/src/org/openstreetmap/josm/gui/io/DownloadPrimitivesTask.java

    r9241 r10129  
    22package org.openstreetmap.josm.gui.io;
    33
    4 import static org.openstreetmap.josm.tools.CheckParameterUtil.ensureParameterNotNull;
    54import static org.openstreetmap.josm.tools.I18n.tr;
    65
    7 import java.io.IOException;
    86import java.util.List;
    9 import java.util.Set;
    107
    11 import org.openstreetmap.josm.Main;
    12 import org.openstreetmap.josm.actions.AutoScaleAction;
    13 import org.openstreetmap.josm.data.osm.DataSet;
    14 import org.openstreetmap.josm.data.osm.DataSetMerger;
    158import org.openstreetmap.josm.data.osm.Node;
    169import org.openstreetmap.josm.data.osm.OsmPrimitive;
    17 import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
    1810import org.openstreetmap.josm.data.osm.PrimitiveId;
    1911import org.openstreetmap.josm.data.osm.Relation;
    2012import org.openstreetmap.josm.data.osm.Way;
    21 import org.openstreetmap.josm.gui.ExceptionDialogUtil;
    22 import org.openstreetmap.josm.gui.PleaseWaitRunnable;
    2313import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    2414import org.openstreetmap.josm.gui.progress.ProgressMonitor;
    25 import org.openstreetmap.josm.gui.util.GuiHelper;
    2615import org.openstreetmap.josm.io.MultiFetchServerObjectReader;
    27 import org.openstreetmap.josm.io.OsmServerObjectReader;
    28 import org.openstreetmap.josm.io.OsmTransferException;
    29 import org.xml.sax.SAXException;
    3016
    3117/**
     
    3319 * @since 4081
    3420 */
    35 public class DownloadPrimitivesTask extends PleaseWaitRunnable {
    36     private DataSet ds;
    37     private boolean canceled;
    38     private Exception lastException;
     21public class DownloadPrimitivesTask extends AbstractPrimitiveTask {
     22
    3923    private final List<PrimitiveId> ids;
    40 
    41     private Set<PrimitiveId> missingPrimitives;
    42 
    43     private final OsmDataLayer layer;
    44     private final boolean fullRelation;
    45     private MultiFetchServerObjectReader multiObjectReader;
    46     private OsmServerObjectReader objectReader;
    4724
    4825    /**
     
    7350    public DownloadPrimitivesTask(OsmDataLayer layer, List<PrimitiveId> ids, boolean fullRelation,
    7451            ProgressMonitor progressMonitor) {
    75         super(tr("Download objects"), progressMonitor, false /* don't ignore exception */);
    76         ensureParameterNotNull(layer, "layer");
     52        super(tr("Download objects"), progressMonitor, layer);
    7753        this.ids = ids;
    78         this.layer = layer;
    79         this.fullRelation = fullRelation;
     54        setZoom(true);
     55        setDownloadRelations(true, fullRelation);
    8056    }
    8157
    8258    @Override
    83     protected void cancel() {
    84         canceled = true;
    85         synchronized (this) {
    86             if (multiObjectReader != null) {
    87                 multiObjectReader.cancel();
    88             }
    89             if (objectReader != null) {
    90                 objectReader.cancel();
    91             }
    92         }
    93     }
    94 
    95     @Override
    96     protected void finish() {
    97         if (canceled)
    98             return;
    99         if (lastException != null) {
    100             ExceptionDialogUtil.explainException(lastException);
    101             return;
    102         }
    103         GuiHelper.runInEDTAndWait(new Runnable() {
    104             @Override
    105             public void run() {
    106                 layer.mergeFrom(ds);
    107                 if (Main.map != null)
    108                     AutoScaleAction.zoomTo(ds.allPrimitives());
    109                 layer.onPostDownloadFromServer();
    110             }
    111         });
    112     }
    113 
    11459    protected void initMultiFetchReader(MultiFetchServerObjectReader reader) {
    11560        getProgressMonitor().indeterminateSubTask(tr("Initializing nodes to download ..."));
     
    13378        }
    13479    }
    135 
    136     @Override
    137     protected void realRun() throws SAXException, IOException, OsmTransferException {
    138         this.ds = new DataSet();
    139         DataSet theirDataSet;
    140         try {
    141             synchronized (this) {
    142                 if (canceled) return;
    143                 multiObjectReader = MultiFetchServerObjectReader.create();
    144             }
    145             initMultiFetchReader(multiObjectReader);
    146             theirDataSet = multiObjectReader.parseOsm(progressMonitor.createSubTaskMonitor(ProgressMonitor.ALL_TICKS, false));
    147             missingPrimitives = multiObjectReader.getMissingPrimitives();
    148             synchronized (this) {
    149                 multiObjectReader = null;
    150             }
    151             DataSetMerger merger = new DataSetMerger(ds, theirDataSet);
    152             merger.merge();
    153 
    154             // if incomplete relation members exist, download them too
    155             for (Relation r : ds.getRelations()) {
    156                 if (canceled) return;
    157                 // Relations may be incomplete in case of nested relations if child relations are accessed before their parent
    158                 // (it may happen because "relations" has no deterministic sort order, see #10388)
    159                 if (r.isIncomplete() || r.hasIncompleteMembers()) {
    160                     synchronized (this) {
    161                         if (canceled) return;
    162                         objectReader = new OsmServerObjectReader(r.getId(), OsmPrimitiveType.RELATION, fullRelation);
    163                     }
    164                     theirDataSet = objectReader.parseOsm(progressMonitor.createSubTaskMonitor(ProgressMonitor.ALL_TICKS, false));
    165                     synchronized (this) {
    166                         objectReader = null;
    167                     }
    168                     merger = new DataSetMerger(ds, theirDataSet);
    169                     merger.merge();
    170                 }
    171             }
    172 
    173             // a way loaded with MultiFetch may have incomplete nodes because at least one of its
    174             // nodes isn't present in the local data set. We therefore fully load all
    175             // ways with incomplete nodes.
    176             //
    177             for (Way w : ds.getWays()) {
    178                 if (canceled) return;
    179                 if (w.hasIncompleteNodes()) {
    180                     synchronized (this) {
    181                         if (canceled) return;
    182                         objectReader = new OsmServerObjectReader(w.getId(), OsmPrimitiveType.WAY, true /* full */);
    183                     }
    184                     theirDataSet = objectReader.parseOsm(progressMonitor.createSubTaskMonitor(ProgressMonitor.ALL_TICKS, false));
    185                     synchronized (this) {
    186                         objectReader = null;
    187                     }
    188                     merger = new DataSetMerger(ds, theirDataSet);
    189                     merger.merge();
    190                 }
    191             }
    192 
    193         } catch (Exception e) {
    194             if (canceled) return;
    195             lastException = e;
    196         }
    197     }
    198 
    199     /**
    200      * replies the set of ids of all primitives for which a fetch request to the
    201      * server was submitted but which are not available from the server (the server
    202      * replied a return code of 404)
    203      *
    204      * @return the set of ids of missing primitives
    205      */
    206     public Set<PrimitiveId> getMissingPrimitives() {
    207         return missingPrimitives;
    208     }
    209 
    21080}
  • trunk/src/org/openstreetmap/josm/gui/io/UpdatePrimitivesTask.java

    r9325 r10129  
    22package org.openstreetmap.josm.gui.io;
    33
    4 import static org.openstreetmap.josm.tools.CheckParameterUtil.ensureParameterNotNull;
    54import static org.openstreetmap.josm.tools.I18n.tr;
    65
    7 import java.io.IOException;
    86import java.util.Collection;
    97import java.util.Collections;
    108
    11 import org.openstreetmap.josm.data.osm.DataSet;
    12 import org.openstreetmap.josm.data.osm.DataSetMerger;
    139import org.openstreetmap.josm.data.osm.Node;
    1410import org.openstreetmap.josm.data.osm.OsmPrimitive;
    15 import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
    1611import org.openstreetmap.josm.data.osm.Relation;
    1712import org.openstreetmap.josm.data.osm.Way;
    18 import org.openstreetmap.josm.gui.ExceptionDialogUtil;
    19 import org.openstreetmap.josm.gui.PleaseWaitRunnable;
    2013import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    21 import org.openstreetmap.josm.gui.progress.ProgressMonitor;
    22 import org.openstreetmap.josm.gui.util.GuiHelper;
    2314import org.openstreetmap.josm.io.MultiFetchServerObjectReader;
    24 import org.openstreetmap.josm.io.OsmServerObjectReader;
    25 import org.openstreetmap.josm.io.OsmTransferException;
    26 import org.xml.sax.SAXException;
    2715
    2816/**
    2917 * The asynchronous task for updating a collection of objects using multi fetch.
    30  *
     18 * @since 2599
    3119 */
    32 public class UpdatePrimitivesTask extends PleaseWaitRunnable {
    33     private DataSet ds;
    34     private boolean canceled;
    35     private Exception lastException;
     20public class UpdatePrimitivesTask extends AbstractPrimitiveTask {
     21
    3622    private final Collection<? extends OsmPrimitive> toUpdate;
    37     private final OsmDataLayer layer;
    38     private MultiFetchServerObjectReader multiObjectReader;
    39     private OsmServerObjectReader objectReader;
    4023
    4124    /**
    42      * Creates the  task
     25     * Constructs a new {@code UpdatePrimitivesTask}.
    4326     *
    4427     * @param layer the layer in which primitives are updated. Must not be null.
     
    4831     */
    4932    public UpdatePrimitivesTask(OsmDataLayer layer, Collection<? extends OsmPrimitive> toUpdate) {
    50         super(tr("Update objects"), false /* don't ignore exception */);
    51         ensureParameterNotNull(layer, "layer");
    52         if (toUpdate == null) {
    53             toUpdate = Collections.emptyList();
    54         }
    55         this.layer = layer;
    56         this.toUpdate = toUpdate;
    57     }
    58 
    59     @Override
    60     protected void cancel() {
    61         canceled = true;
    62         synchronized (this) {
    63             if (multiObjectReader != null) {
    64                 multiObjectReader.cancel();
    65             }
    66             if (objectReader != null) {
    67                 objectReader.cancel();
    68             }
    69         }
    70     }
    71 
    72     @Override
    73     protected void finish() {
    74         if (canceled)
    75             return;
    76         if (lastException != null) {
    77             ExceptionDialogUtil.explainException(lastException);
    78             return;
    79         }
    80         GuiHelper.runInEDTAndWait(new Runnable() {
    81             @Override
    82             public void run() {
    83                 layer.mergeFrom(ds);
    84                 layer.onPostDownloadFromServer();
    85             }
    86         });
     33        super(tr("Update objects"), layer);
     34        this.toUpdate = toUpdate != null ? toUpdate : Collections.<OsmPrimitive>emptyList();
    8735    }
    8836
     
    11765
    11866    @Override
    119     protected void realRun() throws SAXException, IOException, OsmTransferException {
    120         this.ds = new DataSet();
    121         DataSet theirDataSet;
    122         try {
    123             synchronized (this) {
    124                 if (canceled) return;
    125                 multiObjectReader = MultiFetchServerObjectReader.create();
    126             }
    127             initMultiFetchReaderWithNodes(multiObjectReader);
    128             initMultiFetchReaderWithWays(multiObjectReader);
    129             initMultiFetchReaderWithRelations(multiObjectReader);
    130             theirDataSet = multiObjectReader.parseOsm(progressMonitor.createSubTaskMonitor(ProgressMonitor.ALL_TICKS, false));
    131             synchronized (this) {
    132                 multiObjectReader = null;
    133             }
    134             DataSetMerger merger = new DataSetMerger(ds, theirDataSet);
    135             merger.merge();
    136             // a way loaded with MultiFetch may have incomplete nodes because at least one of its
    137             // nodes isn't present in the local data set. We therefore fully load all
    138             // ways with incomplete nodes.
    139             //
    140             for (Way w : ds.getWays()) {
    141                 if (canceled) return;
    142                 if (w.hasIncompleteNodes()) {
    143                     synchronized (this) {
    144                         if (canceled) return;
    145                         objectReader = new OsmServerObjectReader(w.getId(), OsmPrimitiveType.WAY, true /* full */);
    146                     }
    147                     theirDataSet = objectReader.parseOsm(progressMonitor.createSubTaskMonitor(ProgressMonitor.ALL_TICKS, false));
    148                     synchronized (this) {
    149                         objectReader = null;
    150                     }
    151                     merger = new DataSetMerger(ds, theirDataSet);
    152                     merger.merge();
    153                 }
    154             }
    155         } catch (Exception e) {
    156             if (canceled)
    157                 return;
    158             lastException = e;
    159         }
     67    protected void initMultiFetchReader(MultiFetchServerObjectReader reader) {
     68        initMultiFetchReaderWithNodes(reader);
     69        initMultiFetchReaderWithWays(reader);
     70        initMultiFetchReaderWithRelations(reader);
    16071    }
    16172}
  • trunk/src/org/openstreetmap/josm/gui/tagging/presets/TaggingPresetMenu.java

    r9231 r10129  
    123123                sortarray.add((JMenuItem) item);
    124124                if (i == items.length-1) {
    125                     Collections.sort(sortarray, comp);
    126                     int pos = 0;
    127                     for (JMenuItem menuItem : sortarray) {
    128                         int oldPos;
    129                         if (lastSeparator == 0) {
    130                             oldPos = pos;
    131                         } else {
    132                             oldPos = pos+lastSeparator+1;
    133                         }
    134                         menu.add(menuItem, oldPos);
    135                         pos++;
    136                     }
     125                    handleMenuItem(menu, comp, sortarray, lastSeparator);
    137126                    sortarray = new ArrayList<>();
    138127                    lastSeparator = 0;
    139128                }
    140129            } else if (item instanceof JSeparator) {
    141                 Collections.sort(sortarray, comp);
    142                 int pos = 0;
    143                 for (JMenuItem menuItem : sortarray) {
    144                     int oldPos;
    145                     if (lastSeparator == 0) {
    146                         oldPos = pos;
    147                     } else {
    148                         oldPos = pos+lastSeparator+1;
    149                     }
    150                     menu.add(menuItem, oldPos);
    151                     pos++;
    152                 }
     130                handleMenuItem(menu, comp, sortarray, lastSeparator);
    153131                sortarray = new ArrayList<>();
    154132                lastSeparator = i;
     
    156134        }
    157135    }
     136
     137    private static void handleMenuItem(JMenu menu, PresetTextComparator comp, List<JMenuItem> sortarray, int lastSeparator) {
     138        Collections.sort(sortarray, comp);
     139        int pos = 0;
     140        for (JMenuItem menuItem : sortarray) {
     141            int oldPos;
     142            if (lastSeparator == 0) {
     143                oldPos = pos;
     144            } else {
     145                oldPos = pos+lastSeparator+1;
     146            }
     147            menu.add(menuItem, oldPos);
     148            pos++;
     149        }
     150    }
    158151}
Note: See TracChangeset for help on using the changeset viewer.