001    //License: GPL. Copyright 2007 by Immanuel Scholz and others
002    package org.openstreetmap.josm.io;
003    
004    import static org.openstreetmap.josm.tools.I18n.tr;
005    
006    import java.io.IOException;
007    import java.io.StringReader;
008    import java.util.Collection;
009    import java.util.Collections;
010    import java.util.HashMap;
011    import java.util.HashSet;
012    import java.util.Map;
013    import java.util.Set;
014    
015    import javax.xml.parsers.ParserConfigurationException;
016    import javax.xml.parsers.SAXParserFactory;
017    
018    import org.openstreetmap.josm.data.osm.Changeset;
019    import org.openstreetmap.josm.data.osm.IPrimitive;
020    import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
021    import org.openstreetmap.josm.data.osm.PrimitiveId;
022    import org.openstreetmap.josm.data.osm.SimplePrimitiveId;
023    import org.openstreetmap.josm.gui.progress.NullProgressMonitor;
024    import org.openstreetmap.josm.gui.progress.ProgressMonitor;
025    import org.openstreetmap.josm.tools.CheckParameterUtil;
026    import org.xml.sax.Attributes;
027    import org.xml.sax.InputSource;
028    import org.xml.sax.Locator;
029    import org.xml.sax.SAXException;
030    import org.xml.sax.helpers.DefaultHandler;
031    
032    public class DiffResultProcessor  {
033    
034        static private class DiffResultEntry {
035            public long new_id;
036            public int new_version;
037        }
038    
039        /**
040         * mapping from old id to new id and version, the result of parsing the diff result
041         * replied by the server
042         */
043        private Map<PrimitiveId, DiffResultEntry> diffResults = new HashMap<PrimitiveId, DiffResultEntry>();
044        /**
045         * the set of processed primitives *after* the new id, the new version and the new changeset id
046         * is set
047         */
048        private Set<IPrimitive> processed;
049        /**
050         * the collection of primitives being uploaded
051         */
052        private Collection<? extends IPrimitive> primitives;
053    
054        /**
055         * Creates a diff result reader
056         *
057         * @param primitives the collection of primitives which have been uploaded. If null,
058         * assumes an empty collection.
059         */
060        public DiffResultProcessor(Collection<? extends IPrimitive> primitives) {
061            if (primitives == null) {
062                primitives = Collections.emptyList();
063            }
064            this.primitives = primitives;
065            this.processed = new HashSet<IPrimitive>();
066        }
067    
068        /**
069         * Parse the response from a diff upload to the OSM API.
070         *
071         * @param diffUploadResponse the response. Must not be null.
072         * @param progressMonitor a progress monitor. Defaults to {@link NullProgressMonitor#INSTANCE} if null
073         * @throws IllegalArgumentException thrown if diffUploadRequest is null
074         * @throws OsmDataParsingException thrown if the diffUploadRequest can't be parsed successfully
075         *
076         */
077        public  void parse(String diffUploadResponse, ProgressMonitor progressMonitor) throws OsmDataParsingException {
078            if (progressMonitor == null) {
079                progressMonitor = NullProgressMonitor.INSTANCE;
080            }
081            CheckParameterUtil.ensureParameterNotNull(diffUploadResponse, "diffUploadResponse");
082            try {
083                progressMonitor.beginTask(tr("Parsing response from server..."));
084                InputSource inputSource = new InputSource(new StringReader(diffUploadResponse));
085                SAXParserFactory.newInstance().newSAXParser().parse(inputSource, new Parser());
086            } catch(IOException e) {
087                throw new OsmDataParsingException(e);
088            } catch(ParserConfigurationException e) {
089                throw new OsmDataParsingException(e);
090            } catch(OsmDataParsingException e) {
091                throw e;
092            } catch(SAXException e) {
093                throw new OsmDataParsingException(e);
094            } finally {
095                progressMonitor.finishTask();
096            }
097        }
098    
099        /**
100         * Postprocesses the diff result read and parsed from the server.
101         *
102         * Uploaded objects are assigned their new id (if they got assigned a new
103         * id by the server), their new version (if the version was incremented),
104         * and the id of the changeset to which they were uploaded.
105         *
106         * @param cs the current changeset. Ignored if null.
107         * @param monitor the progress monitor. Set to {@link NullProgressMonitor#INSTANCE} if null
108         * @return the collection of processed primitives
109         */
110        protected Set<IPrimitive> postProcess(Changeset cs, ProgressMonitor monitor) {
111            if (monitor == null) {
112                monitor = NullProgressMonitor.INSTANCE;
113            }
114            try {
115                monitor.beginTask("Postprocessing uploaded data ...");
116                monitor.setTicksCount(primitives.size());
117                monitor.setTicks(0);
118                for (IPrimitive p : primitives) {
119                    monitor.worked(1);
120                    DiffResultEntry entry = diffResults.get(p.getPrimitiveId());
121                    if (entry == null) {
122                        continue;
123                    }
124                    processed.add(p);
125                    if (!p.isDeleted()) {
126                        p.setOsmId(entry.new_id, entry.new_version);
127                        p.setVisible(true);
128                    } else {
129                        p.setVisible(false);
130                    }
131                    if (cs != null && !cs.isNew()) {
132                        p.setChangesetId(cs.getId());
133                    }
134                }
135                return processed;
136            } finally {
137                monitor.finishTask();
138            }
139        }
140    
141        private class Parser extends DefaultHandler {
142            private Locator locator;
143    
144            @Override
145            public void setDocumentLocator(Locator locator) {
146                this.locator = locator;
147            }
148    
149            protected void throwException(String msg) throws OsmDataParsingException{
150                throw new OsmDataParsingException(msg).rememberLocation(locator);
151            }
152    
153            @Override public void startElement(String namespaceURI, String localName, String qName, Attributes atts) throws SAXException {
154                try {
155                    if (qName.equals("diffResult")) {
156                        // the root element, ignore
157                    } else if (qName.equals("node") || qName.equals("way") || qName.equals("relation")) {
158    
159                        PrimitiveId id  = new SimplePrimitiveId(
160                                Long.parseLong(atts.getValue("old_id")),
161                                OsmPrimitiveType.fromApiTypeName(qName)
162                        );
163                        DiffResultEntry entry = new DiffResultEntry();
164                        if (atts.getValue("new_id") != null) {
165                            entry.new_id = Long.parseLong(atts.getValue("new_id"));
166                        }
167                        if (atts.getValue("new_version") != null) {
168                            entry.new_version = Integer.parseInt(atts.getValue("new_version"));
169                        }
170                        diffResults.put(id, entry);
171                    } else {
172                        throwException(tr("Unexpected XML element with name ''{0}''", qName));
173                    }
174                } catch (NumberFormatException e) {
175                    throw new OsmDataParsingException(e).rememberLocation(locator);
176                }
177            }
178        }
179    }