001// License: GPL. For details, see LICENSE file.
002package org.openstreetmap.josm.data.osm;
003
004import static org.openstreetmap.josm.tools.I18n.marktr;
005import static org.openstreetmap.josm.tools.I18n.tr;
006import static org.openstreetmap.josm.tools.I18n.trc;
007import static org.openstreetmap.josm.tools.I18n.trcLazy;
008import static org.openstreetmap.josm.tools.I18n.trn;
009
010import java.awt.ComponentOrientation;
011import java.util.ArrayList;
012import java.util.Arrays;
013import java.util.Collection;
014import java.util.Collections;
015import java.util.Comparator;
016import java.util.HashSet;
017import java.util.LinkedList;
018import java.util.List;
019import java.util.Locale;
020import java.util.Map;
021import java.util.Objects;
022import java.util.Set;
023import java.util.stream.Collectors;
024
025import org.openstreetmap.josm.data.coor.LatLon;
026import org.openstreetmap.josm.data.coor.conversion.CoordinateFormatManager;
027import org.openstreetmap.josm.data.osm.history.HistoryNameFormatter;
028import org.openstreetmap.josm.data.osm.history.HistoryNode;
029import org.openstreetmap.josm.data.osm.history.HistoryOsmPrimitive;
030import org.openstreetmap.josm.data.osm.history.HistoryRelation;
031import org.openstreetmap.josm.data.osm.history.HistoryWay;
032import org.openstreetmap.josm.data.preferences.BooleanProperty;
033import org.openstreetmap.josm.data.preferences.CachingProperty;
034import org.openstreetmap.josm.gui.tagging.presets.TaggingPreset;
035import org.openstreetmap.josm.gui.tagging.presets.TaggingPresetNameTemplateList;
036import org.openstreetmap.josm.spi.preferences.Config;
037import org.openstreetmap.josm.tools.AlphanumComparator;
038import org.openstreetmap.josm.tools.I18n;
039import org.openstreetmap.josm.tools.Utils;
040import org.openstreetmap.josm.tools.template_engine.TemplateEngineDataProvider;
041
042/**
043 * This is the default implementation of a {@link NameFormatter} for names of {@link IPrimitive}s
044 * and {@link HistoryOsmPrimitive}s.
045 * @since 12663 (moved from {@code gui} package)
046 * @since 1990
047 */
048public class DefaultNameFormatter implements NameFormatter, HistoryNameFormatter {
049
050    private static DefaultNameFormatter instance;
051
052    private static final List<NameFormatterHook> formatHooks = new LinkedList<>();
053    private static final CachingProperty<Boolean> PROPERTY_SHOW_ID =
054            new BooleanProperty("osm-primitives.showid", false).cached();
055    private static final CachingProperty<Boolean> PROPERTY_SHOW_ID_NEW_PRIMITIVES =
056            new BooleanProperty("osm-primitives.showid.new-primitives", false).cached();
057    private static final CachingProperty<Boolean> PROPERTY_SHOW_VERSION =
058            new BooleanProperty("osm-primitives.showversion", false).cached();
059    private static final CachingProperty<Boolean> PROPERTY_SHOW_COOR =
060            new BooleanProperty("osm-primitives.showcoor", false).cached();
061    private static final CachingProperty<Boolean> PROPERTY_LOCALIZE_NAME =
062            new BooleanProperty("osm-primitives.localize-name", true).cached();
063
064    private static final List<String> HIGHWAY_RAILWAY_WATERWAY_LANDUSE_BUILDING = Arrays.asList(
065            marktr("highway"), marktr("railway"), marktr("waterway"), marktr("landuse"), marktr("building"));
066
067    /**
068     * Replies the unique instance of this formatter
069     *
070     * @return the unique instance of this formatter
071     */
072    public static synchronized DefaultNameFormatter getInstance() {
073        if (instance == null) {
074            instance = new DefaultNameFormatter();
075        }
076        return instance;
077    }
078
079    /**
080     * Registers a format hook. Adds the hook at the first position of the format hooks.
081     * (for plugins)
082     *
083     * @param hook the format hook. Ignored if null.
084     */
085    public static void registerFormatHook(NameFormatterHook hook) {
086        if (hook == null) return;
087        if (!formatHooks.contains(hook)) {
088            formatHooks.add(0, hook);
089        }
090    }
091
092    /**
093     * Unregisters a format hook. Removes the hook from the list of format hooks.
094     *
095     * @param hook the format hook. Ignored if null.
096     */
097    public static void unregisterFormatHook(NameFormatterHook hook) {
098        if (hook == null) return;
099        formatHooks.remove(hook);
100    }
101
102    /** The default list of tags which are used as naming tags in relations.
103     * A ? prefix indicates a boolean value, for which the key (instead of the value) is used.
104     */
105    private static final String[] DEFAULT_NAMING_TAGS_FOR_RELATIONS = {
106            "name",
107            "ref",
108            //
109            "amenity",
110            "landuse",
111            "leisure",
112            "natural",
113            "public_transport",
114            "restriction",
115            "water",
116            "waterway",
117            "wetland",
118            //
119            ":LocationCode",
120            "description",
121            "note",
122            "?building",
123            "?building:part",
124    };
125
126    /** the current list of tags used as naming tags in relations */
127    private static List<String> namingTagsForRelations;
128
129    /**
130     * Replies the list of naming tags used in relations. The list is given (in this order) by:
131     * <ul>
132     *   <li>by the tag names in the preference <code>relation.nameOrder</code></li>
133     *   <li>by the default tags in {@link #DEFAULT_NAMING_TAGS_FOR_RELATIONS}
134     * </ul>
135     *
136     * @return the list of naming tags used in relations
137     */
138    public static synchronized List<String> getNamingtagsForRelations() {
139        if (namingTagsForRelations == null) {
140            namingTagsForRelations = new ArrayList<>(
141                    Config.getPref().getList("relation.nameOrder", Arrays.asList(DEFAULT_NAMING_TAGS_FOR_RELATIONS))
142                    );
143        }
144        return namingTagsForRelations;
145    }
146
147    /**
148     * Decorates the name of primitive with its id and version, if the preferences
149     * <code>osm-primitives.showid</code> and <code>osm-primitives.showversion</code> are set.
150     * Shows unique id if <code>osm-primitives.showid.new-primitives</code> is set
151     *
152     * @param name the name without the id
153     * @param primitive the primitive
154     */
155    protected void decorateNameWithId(StringBuilder name, IPrimitive primitive) {
156        int version = primitive.getVersion();
157        if (Boolean.TRUE.equals(PROPERTY_SHOW_ID.get())) {
158            long id = Boolean.TRUE.equals(PROPERTY_SHOW_ID_NEW_PRIMITIVES.get()) ?
159                    primitive.getUniqueId() : primitive.getId();
160            if (version > 0 && Boolean.TRUE.equals(PROPERTY_SHOW_VERSION.get())) {
161                name.append(tr(" [id: {0}, v{1}]", id, version));
162            } else {
163                name.append(tr(" [id: {0}]", id));
164            }
165        } else if (Boolean.TRUE.equals(PROPERTY_SHOW_VERSION.get())) {
166            name.append(tr(" [v{0}]", version));
167        }
168    }
169
170    /**
171     * Decorates the name of primitive with nodes count
172     *
173     * @param name the name without the nodes count
174     * @param way the way
175     * @since 18808
176     */
177    protected void decorateNameWithNodes(StringBuilder name, IWay<?> way) {
178        char mark;
179        // If current language is left-to-right (almost all languages)
180        if (ComponentOrientation.getOrientation(Locale.getDefault()).isLeftToRight()) {
181            // will insert Left-To-Right Mark to ensure proper display of text in the case when object name is right-to-left
182            mark = '\u200E';
183        } else {
184            // otherwise will insert Right-To-Left Mark to ensure proper display in the opposite case
185            mark = '\u200F';
186        }
187        int nodesNo = way.getRealNodesCount();
188        /* note: length == 0 should no longer happen, but leave the bracket code
189            nevertheless, who knows what future brings */
190        /* I18n: count of nodes as parameter */
191        String nodes = trn("{0} node", "{0} nodes", nodesNo, nodesNo);
192        name.append(mark).append(" (").append(nodes).append(')');
193    }
194
195    /**
196     * Formats a name for an {@link IPrimitive}.
197     *
198     * @param osm the primitive
199     * @return the name
200     * @since 10991
201     * @since 13564 (signature)
202     */
203    public String format(IPrimitive osm) {
204        return osm.getDisplayName(this);
205    }
206
207    @Override
208    public String format(INode node) {
209        StringBuilder name = new StringBuilder();
210        if (node.isIncomplete()) {
211            name.append(tr("incomplete"));
212        } else {
213            TaggingPreset preset = TaggingPresetNameTemplateList.getInstance().findPresetTemplate(node);
214            if (preset == null || !(node instanceof TemplateEngineDataProvider)) {
215                String n = formatLocalName(node);
216                if (n == null) {
217                    n = formatAddress(node);
218                }
219
220                if (n == null) {
221                    n = node.isNew() ? tr("node") : Long.toString(node.getId());
222                }
223                name.append(n);
224            } else {
225                preset.nameTemplate.appendText(name, (TemplateEngineDataProvider) node);
226            }
227            if (node.isLatLonKnown() && Boolean.TRUE.equals(PROPERTY_SHOW_COOR.get())) {
228                name.append(" \u200E(")
229                    .append(CoordinateFormatManager.getDefaultFormat().toString(node, ", "))
230                    .append(")\u200C");
231            }
232        }
233        decorateNameWithId(name, node);
234
235        String result = name.toString();
236        // This avoids memallocs from Stream map, filter and Optional creation.
237        for (NameFormatterHook hook : formatHooks) {
238            final String checkFormat = hook.checkFormat(node, result);
239            if (checkFormat != null) {
240                return checkFormat;
241            }
242        }
243        return result;
244    }
245
246    private final Comparator<INode> nodeComparator = Comparator.comparing(this::format);
247
248    @Override
249    public Comparator<INode> getNodeComparator() {
250        return nodeComparator;
251    }
252
253    @Override
254    public String format(IWay<?> way) {
255        StringBuilder name = new StringBuilder();
256
257        char mark;
258        // If current language is left-to-right (almost all languages)
259        if (ComponentOrientation.getOrientation(Locale.getDefault()).isLeftToRight()) {
260            // will insert Left-To-Right Mark to ensure proper display of text in the case when object name is right-to-left
261            mark = '\u200E';
262        } else {
263            // otherwise will insert Right-To-Left Mark to ensure proper display in the opposite case
264            mark = '\u200F';
265        }
266        // Initialize base direction of the string
267        name.append(mark);
268
269        if (way.isIncomplete()) {
270            name.append(tr("incomplete"));
271        } else {
272            TaggingPreset preset = TaggingPresetNameTemplateList.getInstance().findPresetTemplate(way);
273            if (preset == null || !(way instanceof TemplateEngineDataProvider)) {
274                String n;
275                n = formatLocalName(way);
276                if (n == null) {
277                    n = way.get("ref");
278                }
279                if (n == null) {
280                    n = formatAddress(way);
281                }
282                if (n == null) {
283                    for (String key : HIGHWAY_RAILWAY_WATERWAY_LANDUSE_BUILDING) {
284                        if (way.hasKey(key) && !way.isKeyFalse(key)) {
285                            /* I18N: first is highway, railway, waterway, landuse or building type, second is the type itself */
286                            n = way.isKeyTrue(key) ? tr(key) : tr("{0} ({1})", trcLazy(key, way.get(key)), tr(key));
287                            break;
288                        }
289                    }
290                }
291                if (Utils.isEmpty(n)) {
292                    n = String.valueOf(way.getId());
293                }
294
295                name.append(n);
296            } else {
297                preset.nameTemplate.appendText(name, (TemplateEngineDataProvider) way);
298            }
299
300            decorateNameWithNodes(name, way);
301        }
302        decorateNameWithId(name, way);
303        name.append('\u200C');
304
305        String result = name.toString();
306        return formatHooks.stream().map(hook -> hook.checkFormat(way, result))
307                .filter(Objects::nonNull)
308                .findFirst().orElse(result);
309
310    }
311
312    private static String formatLocalName(IPrimitive osm) {
313        if (Boolean.TRUE.equals(PROPERTY_LOCALIZE_NAME.get())) {
314            return osm.getLocalName();
315        } else {
316            return osm.getName();
317        }
318    }
319
320    private static String formatLocalName(HistoryOsmPrimitive osm) {
321        if (Boolean.TRUE.equals(PROPERTY_LOCALIZE_NAME.get())) {
322            return osm.getLocalName();
323        } else {
324            return osm.getName();
325        }
326    }
327
328    private static String formatAddress(Tagged osm) {
329        String n = null;
330        String s = osm.get("addr:housename");
331        if (s != null) {
332            /* I18n: name of house as parameter */
333            n = tr("House {0}", s);
334        }
335        if (n == null && (s = osm.get("addr:housenumber")) != null) {
336            String t = osm.get("addr:street");
337            if (t != null) {
338                /* I18n: house number, street as parameter, number should remain
339            before street for better visibility */
340                n = tr("House number {0} at {1}", s, t);
341            } else {
342                /* I18n: house number as parameter */
343                n = tr("House number {0}", s);
344            }
345        }
346        return n;
347    }
348
349    private final Comparator<IWay<?>> wayComparator = Comparator.comparing(this::format);
350
351    @Override
352    public Comparator<IWay<?>> getWayComparator() {
353        return wayComparator;
354    }
355
356    @Override
357    public String format(IRelation<?> relation) {
358        StringBuilder name = new StringBuilder();
359        if (relation.isIncomplete()) {
360            name.append(tr("incomplete"));
361        } else {
362            TaggingPreset preset = TaggingPresetNameTemplateList.getInstance().findPresetTemplate(relation);
363
364            formatRelationNameAndType(relation, name, preset);
365
366            int mbno = relation.getMembersCount();
367            name.append(trn("{0} member", "{0} members", mbno, mbno));
368
369            if (relation.hasIncompleteMembers()) {
370                name.append(", ").append(tr("incomplete"));
371            }
372
373            name.append(')');
374        }
375        decorateNameWithId(name, relation);
376
377        String result = name.toString();
378        return formatHooks.stream().map(hook -> hook.checkFormat(relation, result))
379                .filter(Objects::nonNull)
380                .findFirst().orElse(result);
381
382    }
383
384    private static StringBuilder formatRelationNameAndType(IRelation<?> relation, StringBuilder result, TaggingPreset preset) {
385        if (preset == null || !(relation instanceof TemplateEngineDataProvider)) {
386            result.append(getRelationTypeName(relation));
387            String relationName = getRelationName(relation);
388            if (relationName == null) {
389                relationName = Long.toString(relation.getId());
390            } else {
391                relationName = '\"' + relationName + '\"';
392            }
393            result.append(" (").append(relationName).append(", ");
394        } else {
395            preset.nameTemplate.appendText(result, (TemplateEngineDataProvider) relation);
396            result.append(" (");
397        }
398        return result;
399    }
400
401    private final Comparator<IRelation<?>> relationComparator = (r1, r2) -> {
402        //TODO This doesn't work correctly with formatHooks
403
404        TaggingPreset preset1 = TaggingPresetNameTemplateList.getInstance().findPresetTemplate(r1);
405        TaggingPreset preset2 = TaggingPresetNameTemplateList.getInstance().findPresetTemplate(r2);
406
407        if (preset1 != null || preset2 != null) {
408            String name11 = formatRelationNameAndType(r1, new StringBuilder(), preset1).toString();
409            String name21 = formatRelationNameAndType(r2, new StringBuilder(), preset2).toString();
410
411            int comp1 = AlphanumComparator.getInstance().compare(name11, name21);
412            if (comp1 != 0)
413                return comp1;
414        } else {
415
416            String type1 = getRelationTypeName(r1);
417            String type2 = getRelationTypeName(r2);
418
419            int comp2 = AlphanumComparator.getInstance().compare(type1, type2);
420            if (comp2 != 0)
421                return comp2;
422
423            String name12 = getRelationName(r1);
424            String name22 = getRelationName(r2);
425
426            comp2 = AlphanumComparator.getInstance().compare(name12, name22);
427            if (comp2 != 0)
428                return comp2;
429        }
430
431        int comp3 = Integer.compare(r1.getMembersCount(), r2.getMembersCount());
432        if (comp3 != 0)
433            return comp3;
434
435
436        comp3 = Boolean.compare(r1.hasIncompleteMembers(), r2.hasIncompleteMembers());
437        if (comp3 != 0)
438            return comp3;
439
440        return Long.compare(r1.getUniqueId(), r2.getUniqueId());
441    };
442
443    @Override
444    public Comparator<IRelation<?>> getRelationComparator() {
445        return relationComparator;
446    }
447
448    private static String getRelationTypeName(IRelation<?> relation) {
449        // see https://josm.openstreetmap.de/browser/osm/applications/editors/josm/i18n/specialmessages.java
450        String name = trc("Relation type", relation.get("type"));
451        if (name == null) {
452            name = relation.hasKey("public_transport") ? tr("public transport") : null;
453        }
454        if (name == null) {
455            String building = relation.get("building");
456            if (OsmUtils.isTrue(building)) {
457                name = tr("building");
458            } else if (building != null) {
459                name = tr(building); // translate tag!
460            }
461        }
462        if (name == null) {
463            // see https://josm.openstreetmap.de/browser/osm/applications/editors/josm/i18n/specialmessages.java
464            name = trc("Place type", relation.get("place"));
465        }
466        if (name == null) {
467            name = tr("relation");
468        }
469        String adminLevel = relation.get("admin_level");
470        if (adminLevel != null) {
471            name += '['+adminLevel+']';
472        }
473
474        for (NameFormatterHook hook: formatHooks) {
475            String hookResult = hook.checkRelationTypeName(relation, name);
476            if (hookResult != null)
477                return hookResult;
478        }
479
480        return name;
481    }
482
483    private static String getNameTagValue(IRelation<?> relation, String nameTag) {
484        if ("name".equals(nameTag)) {
485            return formatLocalName(relation);
486        } else if (":LocationCode".equals(nameTag)) {
487            return relation.keys()
488                    .filter(m -> m.endsWith(nameTag))
489                    .findFirst()
490                    .map(relation::get)
491                    .orElse(null);
492        } else if (nameTag.startsWith("?") && OsmUtils.isTrue(relation.get(nameTag.substring(1)))) {
493            return tr(nameTag.substring(1));
494        } else if (nameTag.startsWith("?") && OsmUtils.isFalse(relation.get(nameTag.substring(1)))) {
495            return null;
496        } else if (nameTag.startsWith("?")) {
497            return trcLazy(nameTag, I18n.escape(relation.get(nameTag.substring(1))));
498        } else {
499            return trcLazy(nameTag, I18n.escape(relation.get(nameTag)));
500        }
501    }
502
503    private static String getRelationName(IRelation<?> relation) {
504        String nameTag;
505        for (String n : getNamingtagsForRelations()) {
506            nameTag = getNameTagValue(relation, n);
507            if (nameTag != null)
508                return nameTag;
509        }
510        return null;
511    }
512
513    @Override
514    public String format(Changeset changeset) {
515        return tr("Changeset {0}", changeset.getId());
516    }
517
518    /**
519     * Builds a default tooltip text for the primitive <code>primitive</code>.
520     *
521     * @param primitive the primitive
522     * @return the tooltip text
523     */
524    public String buildDefaultToolTip(IPrimitive primitive) {
525        return buildDefaultToolTip(primitive.getId(), primitive.getKeys());
526    }
527
528    private static String buildDefaultToolTip(long id, Map<String, String> tags) {
529        StringBuilder sb = new StringBuilder(128);
530        sb.append("<html><strong>id</strong>=")
531          .append(id)
532          .append("<br>");
533        List<String> keyList = new ArrayList<>(tags.keySet());
534        Collections.sort(keyList);
535        for (int i = 0; i < keyList.size(); i++) {
536            if (i > 0) {
537                sb.append("<br>");
538            }
539            String key = keyList.get(i);
540            sb.append("<strong>")
541              .append(Utils.escapeReservedCharactersHTML(key))
542              .append("</strong>=");
543            String value = tags.get(key);
544            while (!value.isEmpty()) {
545                sb.append(Utils.escapeReservedCharactersHTML(value.substring(0, Math.min(50, value.length()))));
546                if (value.length() > 50) {
547                    sb.append("<br>");
548                    value = value.substring(50);
549                } else {
550                    value = "";
551                }
552            }
553        }
554        sb.append("</html>");
555        return sb.toString();
556    }
557
558    /**
559     * Decorates the name of primitive with its id, if the preference
560     * <code>osm-primitives.showid</code> is set.
561     * <p>
562     * The id is appended to the {@link StringBuilder} passed in <code>name</code>.
563     *
564     * @param name  the name without the id
565     * @param primitive the primitive
566     */
567    protected void decorateNameWithId(StringBuilder name, HistoryOsmPrimitive primitive) {
568        if (Boolean.TRUE.equals(PROPERTY_SHOW_ID.get())) {
569            name.append(tr(" [id: {0}]", primitive.getId()));
570        }
571    }
572
573    @Override
574    public String format(HistoryNode node) {
575        StringBuilder sb = new StringBuilder();
576        String name = formatLocalName(node);
577        if (name == null) {
578            sb.append(node.getId());
579        } else {
580            sb.append(name);
581        }
582        LatLon coord = node.getCoords();
583        if (coord != null) {
584            sb.append(" (")
585            .append(CoordinateFormatManager.getDefaultFormat().latToString(coord))
586            .append(", ")
587            .append(CoordinateFormatManager.getDefaultFormat().lonToString(coord))
588            .append(')');
589        }
590        decorateNameWithId(sb, node);
591        return sb.toString();
592    }
593
594    @Override
595    public String format(HistoryWay way) {
596        StringBuilder sb = new StringBuilder();
597        String name = formatLocalName(way);
598        if (name != null) {
599            sb.append(name);
600        }
601        if (sb.length() == 0 && way.get("ref") != null) {
602            sb.append(way.get("ref"));
603        }
604        if (sb.length() == 0) {
605            if (way.hasKey("highway")) {
606                sb.append(tr("highway"));
607            } else if (way.hasKey("railway")) {
608                sb.append("railway");
609            } else if (way.hasKey("waterway")) {
610                sb.append(tr("waterway"));
611            } else if (way.hasKey("landuse")) {
612                sb.append(tr("landuse"));
613            }
614        }
615
616        int nodesNo = way.isClosed() ? (way.getNumNodes() -1) : way.getNumNodes();
617        String nodes = trn("{0} node", "{0} nodes", nodesNo, nodesNo);
618        if (sb.length() == 0) {
619            sb.append(way.getId());
620        }
621        /* note: length == 0 should no longer happen, but leave the bracket code
622           nevertheless, who knows what future brings */
623        if (sb.length() > 0) {
624            sb.append(" (").append(nodes).append(')');
625        } else {
626            sb.append(nodes);
627        }
628        decorateNameWithId(sb, way);
629        return sb.toString();
630    }
631
632    @Override
633    public String format(HistoryRelation relation) {
634        StringBuilder sb = new StringBuilder();
635        String type = relation.get("type");
636        if (type != null) {
637            sb.append(type);
638        } else {
639            sb.append(tr("relation"));
640        }
641        sb.append(" (");
642        String nameTag = null;
643        Set<String> namingTags = new HashSet<>(getNamingtagsForRelations());
644        for (String n : relation.getTags().keySet()) {
645            // #3328: "note " and " note" are name tags too
646            if (namingTags.contains(n.trim())) {
647                nameTag = formatLocalName(relation);
648                if (nameTag == null) {
649                    nameTag = relation.get(n);
650                }
651            }
652            if (nameTag != null) {
653                break;
654            }
655        }
656        if (nameTag == null) {
657            sb.append(Long.toString(relation.getId())).append(", ");
658        } else {
659            sb.append('\"').append(nameTag).append("\", ");
660        }
661
662        int mbno = relation.getNumMembers();
663        sb.append(trn("{0} member", "{0} members", mbno, mbno)).append(')');
664
665        decorateNameWithId(sb, relation);
666        return sb.toString();
667    }
668
669    /**
670     * Builds a default tooltip text for an HistoryOsmPrimitive <code>primitive</code>.
671     *
672     * @param primitive the primitive
673     * @return the tooltip text
674     */
675    public String buildDefaultToolTip(HistoryOsmPrimitive primitive) {
676        return buildDefaultToolTip(primitive.getId(), primitive.getTags());
677    }
678
679    /**
680     * Formats the given collection of primitives as an HTML unordered list.
681     * @param primitives collection of primitives to format
682     * @param maxElements the maximum number of elements to display
683     * @return HTML unordered list
684     */
685    public String formatAsHtmlUnorderedList(Collection<? extends OsmPrimitive> primitives, int maxElements) {
686        Collection<String> displayNames = primitives.stream().map(x -> x.getDisplayName(this)).collect(Collectors.toList());
687        return Utils.joinAsHtmlUnorderedList(Utils.limit(displayNames, maxElements, "..."));
688    }
689
690    /**
691     * Formats the given primitive as an HTML unordered list.
692     * @param primitive primitive to format
693     * @return HTML unordered list
694     */
695    public String formatAsHtmlUnorderedList(OsmPrimitive primitive) {
696        return formatAsHtmlUnorderedList(Collections.singletonList(primitive), 1);
697    }
698
699    /**
700     * Removes the bidirectional text characters U+200C, U+200E, U+200F from the string
701     * @param string the string
702     * @return the string with the bidirectional text characters removed
703     */
704    public static String removeBiDiCharacters(String string) {
705        return string.replaceAll("[\\u200C\\u200E\\u200F]", "");
706    }
707}