001// License: GPL. See LICENSE file for details. 002package org.openstreetmap.josm.io; 003 004import static org.openstreetmap.josm.tools.I18n.tr; 005 006import java.util.ArrayList; 007import java.util.Collection; 008import java.util.HashMap; 009import java.util.List; 010import java.util.Map; 011 012import org.openstreetmap.josm.Main; 013import org.openstreetmap.josm.data.osm.Changeset; 014import org.openstreetmap.josm.data.osm.DataSet; 015import org.openstreetmap.josm.data.osm.Node; 016import org.openstreetmap.josm.data.osm.OsmPrimitive; 017import org.openstreetmap.josm.data.osm.OsmPrimitiveType; 018import org.openstreetmap.josm.data.osm.PrimitiveId; 019import org.openstreetmap.josm.data.osm.Relation; 020import org.openstreetmap.josm.data.osm.RelationMember; 021import org.openstreetmap.josm.data.osm.RelationMemberData; 022import org.openstreetmap.josm.data.osm.SimplePrimitiveId; 023import org.openstreetmap.josm.data.osm.Way; 024 025/** 026 * Abstract Reader, allowing other implementations than OsmReader (PbfReader in PBF plugin for example) 027 * @author Vincent 028 * 029 */ 030public abstract class AbstractReader { 031 032 /** 033 * The dataset to add parsed objects to. 034 */ 035 protected DataSet ds = new DataSet(); 036 037 protected Changeset uploadChangeset; 038 039 /** the map from external ids to read OsmPrimitives. External ids are 040 * longs too, but in contrast to internal ids negative values are used 041 * to identify primitives unknown to the OSM server 042 */ 043 protected final Map<PrimitiveId, OsmPrimitive> externalIdMap = new HashMap<PrimitiveId, OsmPrimitive>(); 044 045 /** 046 * Data structure for the remaining way objects 047 */ 048 protected final Map<Long, Collection<Long>> ways = new HashMap<Long, Collection<Long>>(); 049 050 /** 051 * Data structure for relation objects 052 */ 053 protected final Map<Long, Collection<RelationMemberData>> relations = new HashMap<Long, Collection<RelationMemberData>>(); 054 055 /** 056 * Replies the parsed data set 057 * 058 * @return the parsed data set 059 */ 060 public DataSet getDataSet() { 061 return ds; 062 } 063 064 /** 065 * Processes the parsed nodes after parsing. Just adds them to 066 * the dataset 067 * 068 */ 069 protected void processNodesAfterParsing() { 070 for (OsmPrimitive primitive: externalIdMap.values()) { 071 if (primitive instanceof Node) { 072 this.ds.addPrimitive(primitive); 073 } 074 } 075 } 076 077 /** 078 * Processes the ways after parsing. Rebuilds the list of nodes of each way and 079 * adds the way to the dataset 080 * 081 * @throws IllegalDataException thrown if a data integrity problem is detected 082 */ 083 protected void processWaysAfterParsing() throws IllegalDataException{ 084 for (Long externalWayId: ways.keySet()) { 085 Way w = (Way)externalIdMap.get(new SimplePrimitiveId(externalWayId, OsmPrimitiveType.WAY)); 086 List<Node> wayNodes = new ArrayList<Node>(); 087 for (long id : ways.get(externalWayId)) { 088 Node n = (Node)externalIdMap.get(new SimplePrimitiveId(id, OsmPrimitiveType.NODE)); 089 if (n == null) { 090 if (id <= 0) 091 throw new IllegalDataException ( 092 tr("Way with external ID ''{0}'' includes missing node with external ID ''{1}''.", 093 externalWayId, 094 id)); 095 // create an incomplete node if necessary 096 // 097 n = (Node)ds.getPrimitiveById(id,OsmPrimitiveType.NODE); 098 if (n == null) { 099 n = new Node(id); 100 ds.addPrimitive(n); 101 } 102 } 103 if (n.isDeleted()) { 104 Main.info(tr("Deleted node {0} is part of way {1}", id, w.getId())); 105 } else { 106 wayNodes.add(n); 107 } 108 } 109 w.setNodes(wayNodes); 110 if (w.hasIncompleteNodes()) { 111 Main.info(tr("Way {0} with {1} nodes has incomplete nodes because at least one node was missing in the loaded data.", 112 externalWayId, w.getNodesCount())); 113 } 114 ds.addPrimitive(w); 115 } 116 } 117 118 /** 119 * Completes the parsed relations with its members. 120 * 121 * @throws IllegalDataException thrown if a data integrity problem is detected, i.e. if a 122 * relation member refers to a local primitive which wasn't available in the data 123 * 124 */ 125 protected void processRelationsAfterParsing() throws IllegalDataException { 126 127 // First add all relations to make sure that when relation reference other relation, the referenced will be already in dataset 128 for (Long externalRelationId : relations.keySet()) { 129 Relation relation = (Relation) externalIdMap.get( 130 new SimplePrimitiveId(externalRelationId, OsmPrimitiveType.RELATION) 131 ); 132 ds.addPrimitive(relation); 133 } 134 135 for (Long externalRelationId : relations.keySet()) { 136 Relation relation = (Relation) externalIdMap.get( 137 new SimplePrimitiveId(externalRelationId, OsmPrimitiveType.RELATION) 138 ); 139 List<RelationMember> relationMembers = new ArrayList<RelationMember>(); 140 for (RelationMemberData rm : relations.get(externalRelationId)) { 141 OsmPrimitive primitive = null; 142 143 // lookup the member from the map of already created primitives 144 primitive = externalIdMap.get(new SimplePrimitiveId(rm.getMemberId(), rm.getMemberType())); 145 146 if (primitive == null) { 147 if (rm.getMemberId() <= 0) 148 // relation member refers to a primitive with a negative id which was not 149 // found in the data. This is always a data integrity problem and we abort 150 // with an exception 151 // 152 throw new IllegalDataException( 153 tr("Relation with external id ''{0}'' refers to a missing primitive with external id ''{1}''.", 154 externalRelationId, 155 rm.getMemberId())); 156 157 // member refers to OSM primitive which was not present in the parsed data 158 // -> create a new incomplete primitive and add it to the dataset 159 // 160 primitive = ds.getPrimitiveById(rm.getMemberId(), rm.getMemberType()); 161 if (primitive == null) { 162 switch (rm.getMemberType()) { 163 case NODE: 164 primitive = new Node(rm.getMemberId()); break; 165 case WAY: 166 primitive = new Way(rm.getMemberId()); break; 167 case RELATION: 168 primitive = new Relation(rm.getMemberId()); break; 169 default: throw new AssertionError(); // can't happen 170 } 171 172 ds.addPrimitive(primitive); 173 externalIdMap.put(new SimplePrimitiveId(rm.getMemberId(), rm.getMemberType()), primitive); 174 } 175 } 176 if (primitive.isDeleted()) { 177 Main.info(tr("Deleted member {0} is used by relation {1}", primitive.getId(), relation.getId())); 178 } else { 179 relationMembers.add(new RelationMember(rm.getRole(), primitive)); 180 } 181 } 182 relation.setMembers(relationMembers); 183 } 184 } 185 186 protected void processChangesetAfterParsing() { 187 if (uploadChangeset != null) { 188 for (Map.Entry<String, String> e : uploadChangeset.getKeys().entrySet()) { 189 ds.addChangeSetTag(e.getKey(), e.getValue()); 190 } 191 } 192 } 193 194 protected final void prepareDataSet() throws IllegalDataException { 195 try { 196 ds.beginUpdate(); 197 processNodesAfterParsing(); 198 processWaysAfterParsing(); 199 processRelationsAfterParsing(); 200 processChangesetAfterParsing(); 201 } finally { 202 ds.endUpdate(); 203 } 204 } 205}