source: josm/trunk/src/org/openstreetmap/josm/gui/mappaint/styleelement/LabelCompositionStrategy.java

Last change on this file was 19050, checked in by taylor.smock, 36 hours 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: 10.3 KB
Line 
1// License: GPL. For details, see LICENSE file.
2package org.openstreetmap.josm.gui.mappaint.styleelement;
3
4import java.util.ArrayList;
5import java.util.Arrays;
6import java.util.Collections;
7import java.util.List;
8import java.util.Objects;
9import java.util.stream.Collectors;
10
11import org.openstreetmap.josm.data.osm.IPrimitive;
12import org.openstreetmap.josm.spi.preferences.Config;
13import org.openstreetmap.josm.spi.preferences.PreferenceChangeEvent;
14import org.openstreetmap.josm.spi.preferences.PreferenceChangedListener;
15import org.openstreetmap.josm.tools.LanguageInfo;
16import org.openstreetmap.josm.tools.Utils;
17
18/**
19 * <p>Provides an abstract parent class and three concrete sub classes for various
20 * strategies on how to compose the text label which can be rendered close to a node
21 * or within an area in an OSM map.</p>
22 *
23 * <p>The three strategies below support three rules for composing a label:
24 * <ul>
25 * <li>{@link StaticLabelCompositionStrategy} - the label is given by a static text
26 * specified in the MapCSS style file</li>
27 *
28 * <li>{@link TagLookupCompositionStrategy} - the label is given by the content of a
29 * tag whose name specified in the MapCSS style file</li>
30 *
31 * <li>{@link DeriveLabelFromNameTagsCompositionStrategy} - the label is given by the value
32 * of one of the configured "name tags". The list of relevant name tags can be configured
33 * in the JOSM preferences
34 * see the preference options <code>mappaint.nameOrder</code> and <code>mappaint.nameComplementOrder</code>.</li>
35 * </ul>
36 * @since 3987 (creation)
37 * @since 10599 (functional interface)
38 */
39@FunctionalInterface
40public interface LabelCompositionStrategy {
41
42 /**
43 * Replies the text value to be rendered as label for the primitive {@code primitive}.
44 *
45 * @param primitive the primitive
46 *
47 * @return the text value to be rendered or null, if primitive is null or
48 * if no suitable value could be composed
49 */
50 String compose(IPrimitive primitive);
51
52 /**
53 * Strategy where the label is given by a static text specified in the MapCSS style file.
54 */
55 class StaticLabelCompositionStrategy implements LabelCompositionStrategy {
56 private final String defaultLabel;
57
58 public StaticLabelCompositionStrategy(String defaultLabel) {
59 this.defaultLabel = defaultLabel;
60 }
61
62 @Override
63 public String compose(IPrimitive primitive) {
64 return defaultLabel;
65 }
66
67 public String getDefaultLabel() {
68 return defaultLabel;
69 }
70
71 @Override
72 public String toString() {
73 return '{' + getClass().getSimpleName() + " defaultLabel=" + defaultLabel + '}';
74 }
75
76 @Override
77 public int hashCode() {
78 return Objects.hash(defaultLabel);
79 }
80
81 @Override
82 public boolean equals(Object obj) {
83 if (this == obj) return true;
84 if (obj == null || getClass() != obj.getClass()) return false;
85 StaticLabelCompositionStrategy that = (StaticLabelCompositionStrategy) obj;
86 return Objects.equals(defaultLabel, that.defaultLabel);
87 }
88 }
89
90 /**
91 * Strategy where the label is given by the content of a tag whose name specified in the MapCSS style file.
92 */
93 class TagLookupCompositionStrategy implements LabelCompositionStrategy {
94
95 private final String defaultLabelTag;
96
97 public TagLookupCompositionStrategy(String defaultLabelTag) {
98 if (defaultLabelTag != null) {
99 defaultLabelTag = defaultLabelTag.trim();
100 if (defaultLabelTag.isEmpty()) {
101 defaultLabelTag = null;
102 }
103 }
104 this.defaultLabelTag = defaultLabelTag;
105 }
106
107 @Override
108 public String compose(IPrimitive primitive) {
109 if (defaultLabelTag == null) return null;
110 if (primitive == null) return null;
111 return primitive.get(defaultLabelTag);
112 }
113
114 public String getDefaultLabelTag() {
115 return defaultLabelTag;
116 }
117
118 @Override
119 public String toString() {
120 return '{' + getClass().getSimpleName() + " defaultLabelTag=" + defaultLabelTag + '}';
121 }
122
123 @Override
124 public int hashCode() {
125 return Objects.hash(defaultLabelTag);
126 }
127
128 @Override
129 public boolean equals(Object obj) {
130 if (this == obj) return true;
131 if (obj == null || getClass() != obj.getClass()) return false;
132 TagLookupCompositionStrategy that = (TagLookupCompositionStrategy) obj;
133 return Objects.equals(defaultLabelTag, that.defaultLabelTag);
134 }
135 }
136
137 /**
138 * Strategy where the label is given by the value of one of the configured "name tags".
139 * The list of relevant name tags can be configured in the JOSM preferences
140 * see the preference options <code>mappaint.nameOrder</code> and <code>mappaint.nameComplementOrder</code>
141 */
142 class DeriveLabelFromNameTagsCompositionStrategy implements LabelCompositionStrategy, PreferenceChangedListener {
143
144 /**
145 * The list of default name tags from which a label candidate is derived.
146 */
147 private static final String[] DEFAULT_NAME_TAGS = getDefaultNameTags();
148
149 /**
150 * The list of default name complement tags from which a label candidate is derived.
151 */
152 private static final String[] DEFAULT_NAME_COMPLEMENT_TAGS = {
153 "capacity"
154 };
155
156 private List<String> nameTags = new ArrayList<>();
157 private List<String> nameComplementTags = new ArrayList<>();
158
159 /**
160 * <p>Creates the strategy and initializes its name tags from the preferences.</p>
161 */
162 public DeriveLabelFromNameTagsCompositionStrategy() {
163 Config.getPref().addPreferenceChangeListener(this);
164 initNameTagsFromPreferences();
165 }
166
167 /* Is joining an array really that complicated in Java? */
168 private static String[] getDefaultNameTags() {
169 final var tags = new ArrayList<>(Arrays.asList(LanguageInfo.getOSMLocaleCodes("name:")));
170 tags.addAll(Arrays.asList("name",
171 "int_name",
172 "distance",
173 "railway:position",
174 "ref",
175 "operator",
176 "brand",
177 "addr:unit",
178 "addr:flats",
179 "addr:housenumber"));
180 return tags.toArray(String[]::new);
181 }
182
183 private static List<String> buildNameTags(List<String> nameTags) {
184 if (nameTags == null) {
185 return new ArrayList<>();
186 }
187 return nameTags.stream()
188 .filter(tag -> !Utils.isStripEmpty(tag))
189 .collect(Collectors.toList());
190 }
191
192 /**
193 * Sets the name tags to be looked up in order to build up the label.
194 *
195 * @param nameTags the name tags. null values are ignored.
196 */
197 public void setNameTags(List<String> nameTags) {
198 this.nameTags = buildNameTags(nameTags);
199 }
200
201 /**
202 * Sets the name complement tags to be looked up in order to build up the label.
203 *
204 * @param nameComplementTags the name complement tags. null values are ignored.
205 * @since 6541
206 */
207 public void setNameComplementTags(List<String> nameComplementTags) {
208 this.nameComplementTags = buildNameTags(nameComplementTags);
209 }
210
211 /**
212 * Replies an unmodifiable list of the name tags used to compose the label.
213 *
214 * @return the list of name tags
215 */
216 public List<String> getNameTags() {
217 return Collections.unmodifiableList(nameTags);
218 }
219
220 /**
221 * Replies an unmodifiable list of the name complement tags used to compose the label.
222 *
223 * @return the list of name complement tags
224 * @since 6541
225 */
226 public List<String> getNameComplementTags() {
227 return Collections.unmodifiableList(nameComplementTags);
228 }
229
230 /**
231 * Initializes the name tags to use from a list of default name tags (see
232 * {@link #DEFAULT_NAME_TAGS} and {@link #DEFAULT_NAME_COMPLEMENT_TAGS})
233 * and from name tags configured in the preferences using the keys
234 * <code>mappaint.nameOrder</code> and <code>mappaint.nameComplementOrder</code>.
235 */
236 public final void initNameTagsFromPreferences() {
237 if (Config.getPref() == null) {
238 this.nameTags = new ArrayList<>(Arrays.asList(DEFAULT_NAME_TAGS));
239 this.nameComplementTags = new ArrayList<>(Arrays.asList(DEFAULT_NAME_COMPLEMENT_TAGS));
240 } else {
241 this.nameTags = new ArrayList<>(
242 Config.getPref().getList("mappaint.nameOrder", Arrays.asList(DEFAULT_NAME_TAGS))
243 );
244 this.nameComplementTags = new ArrayList<>(
245 Config.getPref().getList("mappaint.nameComplementOrder", Arrays.asList(DEFAULT_NAME_COMPLEMENT_TAGS))
246 );
247 }
248 }
249
250 private String getPrimitiveName(IPrimitive n) {
251 StringBuilder name = new StringBuilder();
252 if (!n.hasKeys()) return null;
253 nameTags.stream().map(n::get).filter(Objects::nonNull).findFirst()
254 .ifPresent(name::append);
255 for (String rn : nameComplementTags) {
256 String comp = n.get(rn);
257 if (comp != null) {
258 if (name.length() == 0) {
259 name.append(comp);
260 } else {
261 name.append(" (").append(comp).append(')');
262 }
263 break;
264 }
265 }
266 return name.toString();
267 }
268
269 @Override
270 public String compose(IPrimitive primitive) {
271 if (primitive == null) return null;
272 return getPrimitiveName(primitive);
273 }
274
275 @Override
276 public String toString() {
277 return '{' + getClass().getSimpleName() + '}';
278 }
279
280 @Override
281 public void preferenceChanged(PreferenceChangeEvent e) {
282 if (e.getKey() != null && e.getKey().startsWith("mappaint.name")) {
283 initNameTagsFromPreferences();
284 }
285 }
286 }
287}
Note: See TracBrowser for help on using the repository browser.