source: josm/trunk/src/org/openstreetmap/josm/io/imagery/ImageryReader.java@ 19050

Last change on this file since 19050 was 19050, checked in by taylor.smock, 6 weeks ago

Revert most var changes from r19048, fix most new compile warnings and checkstyle issues

Also, document why various ErrorProne checks were originally disabled and fix
generic SonarLint issues.
  • Property svn:eol-style set to native
File size: 23.2 KB
Line 
1// License: GPL. For details, see LICENSE file.
2package org.openstreetmap.josm.io.imagery;
3
4import java.io.BufferedReader;
5import java.io.Closeable;
6import java.io.IOException;
7import java.util.ArrayList;
8import java.util.Arrays;
9import java.util.HashMap;
10import java.util.List;
11import java.util.Map;
12import java.util.Objects;
13import java.util.Optional;
14import java.util.Stack;
15import java.util.concurrent.ConcurrentHashMap;
16
17import javax.xml.parsers.ParserConfigurationException;
18
19import org.openstreetmap.josm.data.imagery.DefaultLayer;
20import org.openstreetmap.josm.data.imagery.ImageryInfo;
21import org.openstreetmap.josm.data.imagery.ImageryInfo.ImageryBounds;
22import org.openstreetmap.josm.data.imagery.ImageryInfo.ImageryCategory;
23import org.openstreetmap.josm.data.imagery.ImageryInfo.ImageryType;
24import org.openstreetmap.josm.data.imagery.Shape;
25import org.openstreetmap.josm.io.CachedFile;
26import org.openstreetmap.josm.tools.HttpClient;
27import org.openstreetmap.josm.tools.JosmRuntimeException;
28import org.openstreetmap.josm.tools.LanguageInfo;
29import org.openstreetmap.josm.tools.Logging;
30import org.openstreetmap.josm.tools.MultiMap;
31import org.openstreetmap.josm.tools.StringParser;
32import org.openstreetmap.josm.tools.Utils;
33import org.openstreetmap.josm.tools.XmlUtils;
34import org.xml.sax.Attributes;
35import org.xml.sax.InputSource;
36import org.xml.sax.SAXException;
37import org.xml.sax.helpers.DefaultHandler;
38
39/**
40 * Reader to parse the list of available imagery servers from an XML definition file.
41 * <p>
42 * The format is specified in the <a href="https://josm.openstreetmap.de/wiki/Maps">JOSM wiki</a>.
43 */
44public class ImageryReader implements Closeable {
45
46 private final String source;
47 private CachedFile cachedFile;
48 private boolean fastFail;
49
50 private enum State {
51 INIT, // initial state, should always be at the bottom of the stack
52 IMAGERY, // inside the imagery element
53 ENTRY, // inside an entry
54 ENTRY_ATTRIBUTE, // note we are inside an entry attribute to collect the character data
55 PROJECTIONS, // inside projections block of an entry
56 MIRROR, // inside an mirror entry
57 MIRROR_ATTRIBUTE, // note we are inside an mirror attribute to collect the character data
58 MIRROR_PROJECTIONS, // inside projections block of an mirror entry
59 CODE,
60 BOUNDS,
61 SHAPE,
62 NO_TILE,
63 NO_TILESUM,
64 METADATA,
65 DEFAULT_LAYERS,
66 CUSTOM_HTTP_HEADERS,
67 NOOP,
68 UNKNOWN, // element is not recognized in the current context
69 }
70
71 /**
72 * Constructs a {@code ImageryReader} from a given filename, URL or internal resource.
73 *
74 * @param source can be:<ul>
75 * <li>relative or absolute file name</li>
76 * <li>{@code file:///SOME/FILE} the same as above</li>
77 * <li>{@code http://...} a URL. It will be cached on disk.</li>
78 * <li>{@code resource://SOME/FILE} file from the classpath (usually in the current *.jar)</li>
79 * <li>{@code josmdir://SOME/FILE} file inside josm user data directory (since r7058)</li>
80 * <li>{@code josmplugindir://SOME/FILE} file inside josm plugin directory (since r7834)</li></ul>
81 */
82 public ImageryReader(String source) {
83 this.source = source;
84 }
85
86 /**
87 * Parses imagery source.
88 * @return list of imagery info
89 * @throws SAXException if any SAX error occurs
90 * @throws IOException if any I/O error occurs
91 */
92 public List<ImageryInfo> parse() throws SAXException, IOException {
93 Parser parser = new Parser();
94 try {
95 cachedFile = new CachedFile(source);
96 cachedFile.setParam(String.join(",", ImageryInfo.getActiveIds()));
97 cachedFile.setFastFail(fastFail);
98 try (BufferedReader in = cachedFile
99 .setMaxAge(CachedFile.DAYS)
100 .setCachingStrategy(CachedFile.CachingStrategy.IfModifiedSince)
101 .getContentReader()) {
102 InputSource is = new InputSource(in);
103 XmlUtils.parseSafeSAX(is, parser);
104 return parser.entries;
105 }
106 } catch (SAXException e) {
107 throw e;
108 } catch (ParserConfigurationException e) {
109 Logging.error(e); // broken SAXException chaining
110 throw new SAXException(e);
111 }
112 }
113
114 private static final class Parser extends DefaultHandler {
115 private static final String MAX_ZOOM = "max-zoom";
116 private static final String MIN_ZOOM = "min-zoom";
117 private static final String TILE_SIZE = "tile-size";
118 private static final String PRIVACY_POLICY_URL = "privacy-policy-url";
119 private static final String TRUE = "true";
120
121 private StringBuilder accumulator = new StringBuilder();
122
123 private Stack<State> states;
124
125 private List<ImageryInfo> entries;
126
127 /**
128 * Skip the current entry because it has mandatory attributes
129 * that this version of JOSM cannot process.
130 */
131 private boolean skipEntry;
132
133 private ImageryInfo entry;
134 /** In case of mirror parsing this contains the mirror entry */
135 private ImageryInfo mirrorEntry;
136 private ImageryBounds bounds;
137 private final Map<ImageryBounds, ImageryBounds> boundsInterner = new HashMap<>();
138 private Shape shape;
139 // language of last element, does only work for simple ENTRY_ATTRIBUTE's
140 private String lang;
141 private List<String> projections;
142 private MultiMap<String, String> noTileHeaders;
143 private MultiMap<String, String> noTileChecksums;
144 private Map<String, String> metadataHeaders;
145 private List<DefaultLayer> defaultLayers;
146 private Map<String, String> customHttpHeaders;
147
148 @Override
149 public void startDocument() {
150 accumulator = new StringBuilder();
151 skipEntry = false;
152 states = new Stack<>();
153 states.push(State.INIT);
154 entries = new ArrayList<>();
155 entry = null;
156 bounds = null;
157 projections = null;
158 noTileHeaders = null;
159 noTileChecksums = null;
160 customHttpHeaders = null;
161 }
162
163 @Override
164 public void startElement(String namespaceURI, String localName, String qName, Attributes atts) throws SAXException {
165 accumulator.setLength(0);
166 State newState = null;
167 switch (states.peek()) {
168 case INIT:
169 if ("imagery".equals(qName)) {
170 newState = State.IMAGERY;
171 }
172 break;
173 case IMAGERY:
174 if ("entry".equals(qName)) {
175 entry = new ImageryInfo();
176 skipEntry = false;
177 newState = State.ENTRY;
178 noTileHeaders = new MultiMap<>();
179 noTileChecksums = new MultiMap<>();
180 metadataHeaders = new ConcurrentHashMap<>();
181 defaultLayers = new ArrayList<>();
182 customHttpHeaders = new ConcurrentHashMap<>();
183 String best = atts.getValue("eli-best");
184 if (TRUE.equals(best)) {
185 entry.setBestMarked(true);
186 }
187 String overlay = atts.getValue("overlay");
188 if (TRUE.equals(overlay)) {
189 entry.setOverlay(true);
190 }
191 }
192 break;
193 case MIRROR:
194 if (Arrays.asList(
195 "type",
196 "url",
197 "id",
198 MIN_ZOOM,
199 MAX_ZOOM,
200 PRIVACY_POLICY_URL,
201 TILE_SIZE
202 ).contains(qName)) {
203 newState = State.MIRROR_ATTRIBUTE;
204 lang = atts.getValue("lang");
205 } else if ("projections".equals(qName)) {
206 projections = new ArrayList<>();
207 newState = State.MIRROR_PROJECTIONS;
208 }
209 break;
210 case ENTRY:
211 if (Arrays.asList(
212 "name",
213 "id",
214 "oldid",
215 "type",
216 "description",
217 "default",
218 "url",
219 "eula",
220 MIN_ZOOM,
221 MAX_ZOOM,
222 "attribution-text",
223 "attribution-url",
224 "logo-image",
225 "logo-url",
226 "terms-of-use-text",
227 "terms-of-use-url",
228 PRIVACY_POLICY_URL,
229 "permission-ref",
230 "country-code",
231 "category",
232 "icon",
233 "date",
234 TILE_SIZE,
235 "valid-georeference",
236 "mod-tile-features",
237 "transparent",
238 "minimum-tile-expire"
239 ).contains(qName)) {
240 newState = State.ENTRY_ATTRIBUTE;
241 lang = atts.getValue("lang");
242 } else if ("bounds".equals(qName)) {
243 try {
244 bounds = new ImageryBounds(
245 atts.getValue("min-lat") + ',' +
246 atts.getValue("min-lon") + ',' +
247 atts.getValue("max-lat") + ',' +
248 atts.getValue("max-lon"), ",");
249 } catch (IllegalArgumentException e) {
250 Logging.trace(e);
251 break;
252 }
253 newState = State.BOUNDS;
254 } else if ("projections".equals(qName)) {
255 projections = new ArrayList<>();
256 newState = State.PROJECTIONS;
257 } else if ("mirror".equals(qName)) {
258 projections = new ArrayList<>();
259 newState = State.MIRROR;
260 mirrorEntry = new ImageryInfo();
261 } else if ("no-tile-header".equals(qName)) {
262 noTileHeaders.put(atts.getValue("name"), atts.getValue("value"));
263 newState = State.NO_TILE;
264 } else if ("no-tile-checksum".equals(qName)) {
265 noTileChecksums.put(atts.getValue("type"), atts.getValue("value"));
266 newState = State.NO_TILESUM;
267 } else if ("metadata-header".equals(qName)) {
268 metadataHeaders.put(atts.getValue("header-name"), atts.getValue("metadata-key"));
269 newState = State.METADATA;
270 } else if ("default-layers".equals(qName)) {
271 newState = State.DEFAULT_LAYERS;
272 } else if ("custom-http-header".equals(qName)) {
273 customHttpHeaders.put(atts.getValue("header-name"), atts.getValue("header-value"));
274 newState = State.CUSTOM_HTTP_HEADERS;
275 }
276 break;
277 case BOUNDS:
278 if ("shape".equals(qName)) {
279 shape = new Shape();
280 newState = State.SHAPE;
281 }
282 break;
283 case SHAPE:
284 if ("point".equals(qName)) {
285 try {
286 shape.addPoint(atts.getValue("lat"), atts.getValue("lon"));
287 } catch (IllegalArgumentException e) {
288 Logging.trace(e);
289 break;
290 }
291 }
292 break;
293 case PROJECTIONS:
294 case MIRROR_PROJECTIONS:
295 if ("code".equals(qName)) {
296 newState = State.CODE;
297 }
298 break;
299 case DEFAULT_LAYERS:
300 if ("layer".equals(qName)) {
301 newState = State.NOOP;
302 try {
303 defaultLayers.add(new DefaultLayer(
304 entry.getImageryType(),
305 atts.getValue("name"),
306 atts.getValue("style"),
307 atts.getValue("tile-matrix-set")
308 ));
309 } catch (IllegalArgumentException e) {
310 Logging.error(e);
311 }
312 }
313 break;
314 default: // Do nothing
315 }
316 /*
317 * Did not recognize the element, so the new state is UNKNOWN.
318 * This includes the case where we are already inside an unknown
319 * element, i.e. we do not try to understand the inner content
320 * of an unknown element, but wait till it's over.
321 */
322 if (newState == null) {
323 newState = State.UNKNOWN;
324 }
325 states.push(newState);
326 if (newState == State.UNKNOWN && TRUE.equals(atts.getValue("mandatory"))) {
327 skipEntry = true;
328 }
329 }
330
331 @Override
332 public void characters(char[] ch, int start, int length) {
333 accumulator.append(ch, start, length);
334 }
335
336 @Override
337 public void endElement(String namespaceURI, String qName, String rqName) {
338 switch (states.pop()) {
339 case INIT:
340 throw new JosmRuntimeException("parsing error: more closing than opening elements");
341 case ENTRY:
342 if ("entry".equals(qName)) {
343 entry.setNoTileHeaders(noTileHeaders);
344 noTileHeaders = null;
345 entry.setNoTileChecksums(noTileChecksums);
346 noTileChecksums = null;
347 entry.setMetadataHeaders(metadataHeaders);
348 metadataHeaders = null;
349 entry.setDefaultLayers(defaultLayers);
350 defaultLayers = null;
351 entry.setCustomHttpHeaders(customHttpHeaders);
352 customHttpHeaders = null;
353
354 if (!skipEntry) {
355 entries.add(entry);
356 }
357 entry = null;
358 }
359 break;
360 case MIRROR:
361 if (mirrorEntry != null && "mirror".equals(qName)) {
362 entry.addMirror(mirrorEntry);
363 mirrorEntry = null;
364 }
365 break;
366 case MIRROR_ATTRIBUTE:
367 if (mirrorEntry != null) {
368 switch (qName) {
369 case "type":
370 Optional<ImageryType> type = Arrays.stream(ImageryType.values())
371 .filter(t -> Objects.equals(accumulator.toString(), t.getTypeString()))
372 .findFirst();
373 if (type.isPresent()) {
374 mirrorEntry.setImageryType(type.get());
375 } else {
376 mirrorEntry = null;
377 }
378 break;
379 case "id":
380 mirrorEntry.setId(accumulator.toString());
381 break;
382 case "url":
383 mirrorEntry.setUrl(accumulator.toString());
384 break;
385 case PRIVACY_POLICY_URL:
386 mirrorEntry.setPrivacyPolicyURL(accumulator.toString());
387 break;
388 case MIN_ZOOM:
389 case MAX_ZOOM:
390 Optional<Integer> zoom = tryParseInt();
391 if (!zoom.isPresent()) {
392 mirrorEntry = null;
393 } else {
394 if (MIN_ZOOM.equals(qName)) {
395 mirrorEntry.setDefaultMinZoom(zoom.get());
396 } else {
397 mirrorEntry.setDefaultMaxZoom(zoom.get());
398 }
399 }
400 break;
401 case TILE_SIZE:
402 Optional<Integer> tileSize = tryParseInt();
403 if (!tileSize.isPresent()) {
404 mirrorEntry = null;
405 } else {
406 entry.setTileSize(tileSize.get());
407 }
408 break;
409 default: // Do nothing
410 }
411 }
412 break;
413 case ENTRY_ATTRIBUTE:
414 switch (qName) {
415 case "name":
416 entry.setName(lang == null ? LanguageInfo.getJOSMLocaleCode(null) : lang, accumulator.toString());
417 break;
418 case "description":
419 entry.setDescription(lang, accumulator.toString());
420 break;
421 case "date":
422 entry.setDate(accumulator.toString());
423 break;
424 case "id":
425 entry.setId(accumulator.toString());
426 break;
427 case "oldid":
428 entry.addOldId(accumulator.toString());
429 break;
430 case "type":
431 ImageryType type = ImageryType.fromString(accumulator.toString());
432 if (type != null)
433 entry.setImageryType(type);
434 else
435 skipEntry = true;
436 break;
437 case "default":
438 switch (accumulator.toString()) {
439 case TRUE:
440 entry.setDefaultEntry(true);
441 break;
442 case "false":
443 entry.setDefaultEntry(false);
444 break;
445 default:
446 skipEntry = true;
447 }
448 break;
449 case "url":
450 entry.setUrl(accumulator.toString());
451 break;
452 case "eula":
453 entry.setEulaAcceptanceRequired(accumulator.toString());
454 break;
455 case MIN_ZOOM:
456 case MAX_ZOOM:
457 Optional<Integer> zoom = tryParseInt();
458 if (!zoom.isPresent()) {
459 skipEntry = true;
460 } else {
461 if (MIN_ZOOM.equals(qName)) {
462 entry.setDefaultMinZoom(zoom.get());
463 } else {
464 entry.setDefaultMaxZoom(zoom.get());
465 }
466 }
467 break;
468 case "attribution-text":
469 entry.setAttributionText(accumulator.toString());
470 break;
471 case "attribution-url":
472 entry.setAttributionLinkURL(accumulator.toString());
473 break;
474 case "logo-image":
475 entry.setAttributionImage(accumulator.toString());
476 break;
477 case "logo-url":
478 entry.setAttributionImageURL(accumulator.toString());
479 break;
480 case "terms-of-use-text":
481 entry.setTermsOfUseText(accumulator.toString());
482 break;
483 case PRIVACY_POLICY_URL:
484 entry.setPrivacyPolicyURL(accumulator.toString());
485 break;
486 case "permission-ref":
487 entry.setPermissionReferenceURL(accumulator.toString());
488 break;
489 case "terms-of-use-url":
490 entry.setTermsOfUseURL(accumulator.toString());
491 break;
492 case "country-code":
493 entry.setCountryCode(accumulator.toString());
494 break;
495 case "icon":
496 entry.setIcon(accumulator.toString());
497 break;
498 case TILE_SIZE:
499 Optional<Integer> tileSize = tryParseInt();
500 if (!tileSize.isPresent()) {
501 skipEntry = true;
502 } else {
503 entry.setTileSize(tileSize.get());
504 }
505 break;
506 case "valid-georeference":
507 entry.setGeoreferenceValid(Boolean.parseBoolean(accumulator.toString()));
508 break;
509 case "mod-tile-features":
510 entry.setModTileFeatures(Boolean.parseBoolean(accumulator.toString()));
511 break;
512 case "transparent":
513 entry.setTransparent(Boolean.parseBoolean(accumulator.toString()));
514 break;
515 case "minimum-tile-expire":
516 entry.setMinimumTileExpire(Integer.parseInt(accumulator.toString()));
517 break;
518 case "category":
519 String cat = accumulator.toString();
520 ImageryCategory category = ImageryCategory.fromString(cat);
521 if (category != null)
522 entry.setImageryCategory(category);
523 entry.setImageryCategoryOriginalString(cat);
524 break;
525 default: // Do nothing
526 }
527 break;
528 case BOUNDS:
529 entry.setBounds(intern(bounds));
530 bounds = null;
531 break;
532 case SHAPE:
533 bounds.addShape(shape);
534 shape = null;
535 break;
536 case CODE:
537 projections.add(accumulator.toString());
538 break;
539 case PROJECTIONS:
540 entry.setServerProjections(projections);
541 projections = null;
542 break;
543 case MIRROR_PROJECTIONS:
544 mirrorEntry.setServerProjections(projections);
545 projections = null;
546 break;
547 case NO_TILE:
548 case NO_TILESUM:
549 case METADATA:
550 case UNKNOWN:
551 default:
552 // nothing to do for these or the unknown type
553 }
554 }
555
556 private ImageryBounds intern(ImageryBounds imageryBounds) {
557 return boundsInterner.computeIfAbsent(imageryBounds, ignore -> imageryBounds);
558 }
559
560 private Optional<Integer> tryParseInt() {
561 return StringParser.DEFAULT.tryParse(Integer.class, accumulator.toString());
562 }
563 }
564
565 /**
566 * Sets whether opening HTTP connections should fail fast, i.e., whether a
567 * {@link HttpClient#setConnectTimeout(int) low connect timeout} should be used.
568 * @param fastFail whether opening HTTP connections should fail fast
569 * @see CachedFile#setFastFail(boolean)
570 */
571 public void setFastFail(boolean fastFail) {
572 this.fastFail = fastFail;
573 }
574
575 @Override
576 public void close() throws IOException {
577 Utils.close(cachedFile);
578 }
579}
Note: See TracBrowser for help on using the repository browser.