Index: src/org/openstreetmap/josm/data/validation/tests/ConditionalKeys.java =================================================================== --- src/org/openstreetmap/josm/data/validation/tests/ConditionalKeys.java (revision 15553) +++ src/org/openstreetmap/josm/data/validation/tests/ConditionalKeys.java (working copy) @@ -16,6 +16,7 @@ import org.openstreetmap.josm.data.validation.Severity; import org.openstreetmap.josm.data.validation.Test; import org.openstreetmap.josm.data.validation.TestError; +import org.openstreetmap.josm.tools.Access; import org.openstreetmap.josm.tools.LanguageInfo; import org.openstreetmap.josm.tools.Logging; import org.openstreetmap.josm.tools.SubclassFilteredCollection; @@ -30,13 +31,8 @@ private static final Set RESTRICTION_TYPES = new HashSet<>(Arrays.asList("oneway", "toll", "noexit", "maxspeed", "minspeed", "maxstay", "maxweight", "maxaxleload", "maxheight", "maxwidth", "maxlength", "overtaking", "maxgcweight", "maxgcweightrating", "fee", "restriction", "interval")); - private static final Set RESTRICTION_VALUES = new HashSet<>(Arrays.asList("yes", "official", "designated", "destination", - "delivery", "customers", "permissive", "private", "agricultural", "forestry", "no")); - private static final Set TRANSPORT_MODES = new HashSet<>(Arrays.asList("access", "foot", "ski", "inline_skates", "ice_skates", - "horse", "vehicle", "bicycle", "carriage", "trailer", "caravan", "motor_vehicle", "motorcycle", "moped", "mofa", - "motorcar", "motorhome", "psv", "bus", "taxi", "tourist_bus", "goods", "hgv", "agricultural", "atv", "snowmobile", - "hgv_articulated", "ski:nordic", "ski:alpine", "ski:telemark", "coach", "golf_cart" - /*,"minibus","share_taxi","hov","car_sharing","emergency","hazmat","disabled"*/)); + private static final Set RESTRICTION_VALUES = Access.getRestrictionValues(); + private static final Set TRANSPORT_MODES = Access.getTransportModes(); private static final Pattern CONDITIONAL_PATTERN; static { Index: src/org/openstreetmap/josm/tools/Access.java =================================================================== --- src/org/openstreetmap/josm/tools/Access.java (nonexistent) +++ src/org/openstreetmap/josm/tools/Access.java (working copy) @@ -0,0 +1,540 @@ +// License: GPL. For details, see LICENSE file. +package org.openstreetmap.josm.tools; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Objects; +import java.util.Set; +import java.util.stream.Collectors; + +/** + * Access tag related utilities + * + * @see Key:access + * + * @author Taylor Smock + * @since xxx + */ +public class Access { + /** + * Holds access tags to avoid typos + */ + public enum AccessTags { + /** + * @see Key:access + */ + ACCESS_KEY("access"), + + // Access tag values + /** + * @see Tag:access%3Dyes + */ + YES("yes"), + /** + * @see Tag:access%3Dofficial + */ + OFFICIAL("official"), + /** + * @see Tag:access%3Ddesignated + */ + DESIGNATED("designated"), + /** + * @see Tag:access%3Ddestination + */ + DESTINATION("destination"), + /** + * @see Tag:access%3Ddelivery + */ + DELIVERY("delivery"), + /** + * @see Tag:access%3Dcustomers + */ + CUSTOMERS("customers"), + /** + * @see Tag:access%3Dpermissive + */ + PERMISSIVE("permissive"), + /** + * @see Tag:access%3Dagricultural + */ + AGRICULTURAL("agricultural"), + /** + * @see Tag:access%3Dforestry + */ + FORESTRY("forestry"), + /** + * @see Tag:access%3Dprivate + */ + PRIVATE("private"), + /** + * @see Tag:access%3Dno + */ + NO("no"), + /** + * @see Tag:access%3Ddiscouraged + */ + DISCOURAGED("discouraged"), + /** + * @see Tag:access%3Duse_sidepath + */ + USE_SIDEPATH("use_sidepath"), + /** + * @see Tag:access%3Ddismount + */ + DISMOUNT("dismount"), + // Land + /** + * @see Key:vehicle + */ + VEHICLE("vehicle"), + /** + * @see Key:motor_vehicle + */ + MOTOR_VEHICLE("motor_vehicle"), + /** + * @see Key:trailer + */ + TRAILER("trailer"), + /** @see Key:foot */ + FOOT("foot"), + /** @see Key:ski */ + SKI("ski"), + /** + * @see Key:inline_skates + */ + INLINE_SKATES("inline_skates"), + /** + * @see Key:ice_skates + */ + ICE_SKATES("ice_skates"), + /** + * @see Key:horse + */ + HORSE("horse"), + /** + * @see Key:bicycle + */ + BICYCLE("bicycle"), + /** + * @see Key:carriage + */ + CARRIAGE("carriage"), + /** + * @see Key:caravan + */ + CARAVAN("caravan"), + /** + * @see Key:motorcycle + */ + MOTORCYCLE("motorcycle"), + /** + * @see Key:moped + */ + MOPED("moped"), + /** @see Key:mofa */ + MOFA("mofa"), + /** + * @see Key:motorcar + */ + MOTORCAR("motorcar"), + /** + * @see Key:motorhome + */ + MOTORHOME("motorhome"), + /** @see Key:psv */ + PSV("psv"), + /** @see Key:bus */ + BUS("bus"), + /** @see Key:taxi */ + TAXI("taxi"), + /** + * @see Key:tourist_bus + */ + TOURIST_BUS("tourist_bus"), + /** + * @see Key:goods + */ + GOODS("goods"), + /** @see Key:hgv */ + HGV("hgv"), + /** @see Key:atv */ + ATV("atv"), + /** + * @see Key:snowmobile + */ + SNOWMOBILE("snowmobile"), + /** + * @see Key:hgv_articulated + */ + HGV_ARTICULATED("hgv_articulated"), + /** @see Key:ski */ + SKI_NORDIC("ski:nordic"), + /** @see Key:ski */ + SKI_ALPINE("ski:alpine"), + /** @see Key:ski */ + SKI_TELEMARK("ski:telemark"), + /** + * @see Key:coach + */ + COACH("coach"), + /** + * @see Key:golf_cart + */ + GOLF_CART("golf_cart"), + /** + * @see Key:minibus + */ + MINIBUS("minibus"), + /** + * @see Key:share_taxi + */ + SHARE_TAXI("share_taxi"), + /** @see Key:hov */ + HOV("hov"), + /** + * @see Key:car_sharing + */ + CAR_SHARING("car_sharing"), + /** + * Routers should default to {@code yes}, regardless of higher access rules, + * assuming it is navigatible by vehicle + * + * @see Key:emergency + */ + EMERGENCY("emergency"), + /** + * @see Key:hazmat + */ + HAZMAT("hazmat"), + /** + * @see Key:disabled + */ + DISABLED("disabled"), + + // Water + /** + * @see Key:swimming + */ + SWIMMING("swimming"), + /** @see Key:boat */ + BOAT("boat"), + /** + * @see Key:fishing_vessel + */ + FISHING_VESSEL("fishing_vessel"), + /** @see Key:ship */ + SHIP("ship"), + /** + * @see Key:motorboat + */ + MOTORBOAT("motorboat"), + /** + * @see Key:sailboat + */ + SAILBOAT("sailboat"), + /** + * @see Key:canoe + */ + CANOE("canoe"), + /** + * @see Key:passenger + */ + PASSENGER("passenger"), + /** + * @see Key:cargo + */ + CARGO("cargo"), + /** @see Key:isps */ + ISPS("isps"), + /** @see Key:bulk */ + BULK("bulk"), + /** + * @see Key:tanker + */ + TANKER("tanker"), + /** + * @see Key:container + */ + CONTAINER("container"), + /** @see Key:imdg */ + IMDG("imdg"), + /** + * @see Key:tanker + */ + TANKER_GAS("tanker:gas"), + /** + * @see Key:tanker + */ + TANKER_OIL("tanker:oil"), + /** + * @see Key:tanker + */ + TANKER_CHEMICAL("tanker:chemical"), + /** + * @see Key:tanker + */ + TANKER_SINGLEHULL("tanker:singlehull"), + + // Trains + /** + * @see Key:train + */ + TRAIN("train"); + + private String key; + + AccessTags(String key) { + this.key = key; + } + + /** + * @return The key for the enum + */ + public String getKey() { + return key; + } + } + /** + * The key for children modes for the map, see {@link Access#getAccessMethods} + */ + public static final String CHILDREN = "children"; + /** The key for parent modes for the map, see {@link Access#getAccessMethods} */ + public static final String PARENT = "parent"; + /** This set has keys that indicate that access is possible */ + private static final Set POSITIVE_ACCESS = new HashSet<>(Arrays.asList(AccessTags.YES, AccessTags.OFFICIAL, + AccessTags.DESIGNATED, AccessTags.DESTINATION, AccessTags.DELIVERY, AccessTags.CUSTOMERS, + AccessTags.PERMISSIVE, AccessTags.AGRICULTURAL, AccessTags.FORESTRY).stream().map(AccessTags::getKey) + .collect(Collectors.toSet())); + /** This set has all basic restriction values (yes/no/permissive/private/...) */ + private static final Set RESTRICTION_VALUES = new HashSet<>( + Arrays.asList(AccessTags.PRIVATE, AccessTags.NO).stream().map(AccessTags::getKey) + .collect(Collectors.toSet())); + /** This set has transport modes (access/foot/ski/motor_vehicle/vehicle/...) */ + private static final Set TRANSPORT_MODES = new HashSet<>( + Arrays.asList(AccessTags.ACCESS_KEY, AccessTags.FOOT, AccessTags.SKI, AccessTags.INLINE_SKATES, + AccessTags.ICE_SKATES, AccessTags.HORSE, AccessTags.VEHICLE, AccessTags.BICYCLE, + AccessTags.CARRIAGE, AccessTags.TRAILER, AccessTags.CARAVAN, AccessTags.MOTOR_VEHICLE, + AccessTags.MOTORCYCLE, AccessTags.MOPED, AccessTags.MOFA, AccessTags.MOTORCAR, AccessTags.MOTORHOME, + AccessTags.PSV, AccessTags.BUS, AccessTags.TAXI, AccessTags.TOURIST_BUS, AccessTags.GOODS, + AccessTags.HGV, AccessTags.AGRICULTURAL, AccessTags.ATV, + AccessTags.SNOWMOBILE, AccessTags.HGV_ARTICULATED, AccessTags.SKI_NORDIC, AccessTags.SKI_ALPINE, + AccessTags.SKI_TELEMARK, AccessTags.COACH, AccessTags.GOLF_CART + /* + * ,"minibus","share_taxi","hov","car_sharing","emergency","hazmat","disabled" + */).stream().map(AccessTags::getKey).collect(Collectors.toSet())); + + /** Map> */ + private static final Map>> accessMethods = new HashMap<>(); + static { + RESTRICTION_VALUES.addAll(POSITIVE_ACCESS); + defaultInheritance(); + } + + private Access() { + // Hide the constructor + } + + /** + * Create the default access inheritance, as defined at + * {@link "https://wiki.openstreetmap.org/wiki/Key:access#Transport_mode_restrictions"} + */ + private static void defaultInheritance() { + addMode(null, AccessTags.ACCESS_KEY); + + // Land + addModes(AccessTags.ACCESS_KEY, AccessTags.FOOT, AccessTags.SKI, AccessTags.INLINE_SKATES, + AccessTags.ICE_SKATES, AccessTags.HORSE, AccessTags.VEHICLE); + addModes(AccessTags.SKI, AccessTags.SKI_NORDIC, AccessTags.SKI_ALPINE, AccessTags.SKI_TELEMARK); + addModes(AccessTags.VEHICLE, AccessTags.BICYCLE, AccessTags.CARRIAGE, AccessTags.TRAILER, + AccessTags.MOTOR_VEHICLE); + addModes(AccessTags.TRAILER, AccessTags.CARAVAN); + addModes(AccessTags.MOTOR_VEHICLE, AccessTags.MOTORCYCLE, AccessTags.MOPED, AccessTags.MOFA, + AccessTags.MOTORCAR, AccessTags.MOTORHOME, AccessTags.TOURIST_BUS, AccessTags.COACH, AccessTags.GOODS, + AccessTags.HGV, AccessTags.AGRICULTURAL, AccessTags.GOLF_CART, AccessTags.ATV, AccessTags.SNOWMOBILE, + AccessTags.PSV, AccessTags.HOV, AccessTags.CAR_SHARING, AccessTags.EMERGENCY, AccessTags.HAZMAT, + AccessTags.DISABLED); + addMode(AccessTags.HGV, AccessTags.HGV_ARTICULATED); + addModes(AccessTags.PSV, AccessTags.BUS, AccessTags.MINIBUS, AccessTags.SHARE_TAXI, AccessTags.TAXI); + + // Water + addModes(AccessTags.ACCESS_KEY, AccessTags.SWIMMING, AccessTags.BOAT, AccessTags.FISHING_VESSEL, + AccessTags.SHIP); + addModes(AccessTags.BOAT, AccessTags.MOTORBOAT, AccessTags.SAILBOAT, AccessTags.CANOE); + addModes(AccessTags.SHIP, AccessTags.PASSENGER, AccessTags.CARGO, AccessTags.ISPS); + addModes(AccessTags.CARGO, AccessTags.BULK, AccessTags.TANKER, AccessTags.CONTAINER, AccessTags.IMDG); + addModes(AccessTags.TANKER, AccessTags.TANKER_GAS, AccessTags.TANKER_OIL, AccessTags.TANKER_CHEMICAL, + AccessTags.TANKER_SINGLEHULL); + + // Rail + addModes(AccessTags.ACCESS_KEY, AccessTags.TRAIN); + } + + /** + * Add multiple modes with a common parent + * + * @param parent The parent of all the modes + * @param modes The modes to add + */ + public static void addModes(AccessTags parent, AccessTags... modes) { + for (AccessTags mode : modes) { + addMode(parent, mode); + } + } + + /** + * Add modes to a list, modifying parents as needed + * + * @param mode The mode to be added + * @param parent The parent of the mode + */ + public static void addMode(AccessTags parent, AccessTags mode) { + Objects.requireNonNull(mode, "Mode must not be null"); + if (parent != null) { + Map> parentMap = accessMethods.getOrDefault(parent.getKey(), new HashMap<>()); + accessMethods.putIfAbsent(parent.getKey(), parentMap); + List parentChildren = parentMap.getOrDefault(CHILDREN, new ArrayList<>()); + if (!parentChildren.contains(mode.getKey())) + parentChildren.add(mode.getKey()); + parentMap.putIfAbsent(CHILDREN, parentChildren); + } + Map> modeMap = accessMethods.getOrDefault(mode.getKey(), new HashMap<>()); + accessMethods.putIfAbsent(mode.getKey(), modeMap); + List modeParent = modeMap.getOrDefault(PARENT, + Collections.singletonList(parent == null ? null : parent.getKey())); + modeMap.putIfAbsent(PARENT, modeParent); + } + + /** + * Expand access modes to cover the children of that access mode (currently only + * supports the default hierarchy) + * + * @param mode The transport mode + * @param access The access value (the children transport modes inherit this + * value) + * @return A map of the mode and its children (does not include parents) + */ + public static Map expandAccessMode(String mode, String access) { + Map accessModes = new HashMap<>(); + accessModes.put(mode, access); + if (accessMethods.containsKey(mode)) { + for (String childrenMode : accessMethods.getOrDefault(mode, Collections.emptyMap()).getOrDefault(CHILDREN, + Collections.emptyList())) { + accessModes.putAll(expandAccessMode(childrenMode, access)); + } + } + return accessModes; + } + + /** + * Merge two access maps (more specific wins) + * + * @param map1 A map with access values (see {@link Access#expandAccessMode}) + * @param map2 A map with access values (see {@link Access#expandAccessMode}) + * @return The merged map + */ + public static Map mergeMaps(Map map1, Map map2) { + Map merged; + if (map1.keySet().containsAll(map2.keySet())) { + merged = new HashMap<>(map1); + merged.putAll(map2); + } else { // if they don't overlap or if map2 contains all of map1 + merged = new HashMap<>(map2); + merged.putAll(map1); + } + return merged; + } + + /** + * Get the set of values that can generally be considered to be accessible + * + * @return A set of values that can be used for routing purposes (unmodifiable) + */ + public static Set getPositiveAccessValues() { + return Collections.unmodifiableSet(POSITIVE_ACCESS); + } + + /** + * Get the valid restriction values ({@code unknown} is not included). See + * + * @return Valid values for restrictions (unmodifiable) + * @see Key:access#List_of_possible_values + */ + public static Set getRestrictionValues() { + return Collections.unmodifiableSet(RESTRICTION_VALUES); + } + + /** + * Get the valid transport modes. See + * + * @return Value transport modes (unmodifiable) + * @see Key:access#Transport_mode_restrictions + */ + public static Set getTransportModes() { + return Collections.unmodifiableSet(TRANSPORT_MODES); + } + + /** + * Get the access method hierarchy. + * + * @return The hierarchy for access modes (unmodifiable) + * @see Key:access#Transport_mode_restrictions + */ + public static Map>> getAccessMethods() { + Map>> map = new HashMap<>(); + for (Entry>> entry : map.entrySet()) { + Map> tMap = new HashMap<>(); + entry.getValue().forEach((key, list) -> tMap.put(key, Collections.unmodifiableList(list))); + map.put(entry.getKey(), Collections.unmodifiableMap(tMap)); + } + return Collections.unmodifiableMap(map); + } +} Index: test/unit/org/openstreetmap/josm/tools/AccessTest.java =================================================================== --- test/unit/org/openstreetmap/josm/tools/AccessTest.java (nonexistent) +++ test/unit/org/openstreetmap/josm/tools/AccessTest.java (working copy) @@ -0,0 +1,59 @@ +// License: GPL. For details, see LICENSE file. +package org.openstreetmap.josm.tools; + +import static org.junit.Assert.assertEquals; + +import java.util.Map; + +import org.junit.Test; + +/** + * Test class for {@link Access} + * + * @author Taylor Smock + * @since xxx + */ +public class AccessTest { + + /** + * Test that access tags inherit the expected values + */ + @Test + public void testInheritance() { + assertEquals(Access.AccessTags.YES.getKey(), + Access.expandAccessMode(Access.AccessTags.VEHICLE.getKey(), Access.AccessTags.YES.getKey()) + .getOrDefault(Access.AccessTags.MOTOR_VEHICLE.getKey(), Access.AccessTags.NO.getKey())); + assertEquals(Access.AccessTags.YES.getKey(), + Access.expandAccessMode(Access.AccessTags.VEHICLE.getKey(), Access.AccessTags.YES.getKey()) + .getOrDefault(Access.AccessTags.HGV.getKey(), Access.AccessTags.NO.getKey())); + assertEquals(Access.AccessTags.YES.getKey(), + Access.expandAccessMode(Access.AccessTags.VEHICLE.getKey(), Access.AccessTags.YES.getKey()) + .getOrDefault(Access.AccessTags.HGV_ARTICULATED.getKey(), Access.AccessTags.NO.getKey())); + } + + /** + * Test that access maps get merged properly ({@link Access#mergeMaps}) + */ + @Test + public void testMergeMaps() { + Map mergedMaps = Access.mergeMaps( + Access.expandAccessMode(Access.AccessTags.VEHICLE.getKey(), Access.AccessTags.YES.getKey()), + Access.expandAccessMode(Access.AccessTags.HGV.getKey(), Access.AccessTags.DESIGNATED.getKey())); + assertEquals(Access.AccessTags.YES.getKey(), + mergedMaps.getOrDefault(Access.AccessTags.MOTORCAR.getKey(), Access.AccessTags.NO.getKey())); + assertEquals(Access.AccessTags.DESIGNATED.getKey(), + mergedMaps.getOrDefault(Access.AccessTags.HGV.getKey(), Access.AccessTags.NO.getKey())); + assertEquals(Access.AccessTags.DESIGNATED.getKey(), + mergedMaps.getOrDefault(Access.AccessTags.HGV_ARTICULATED.getKey(), Access.AccessTags.NO.getKey())); + + mergedMaps = Access.mergeMaps( + Access.expandAccessMode(Access.AccessTags.HGV.getKey(), Access.AccessTags.DESIGNATED.getKey()), + Access.expandAccessMode(Access.AccessTags.VEHICLE.getKey(), Access.AccessTags.YES.getKey())); + assertEquals(Access.AccessTags.YES.getKey(), + mergedMaps.getOrDefault(Access.AccessTags.MOTORCAR.getKey(), Access.AccessTags.NO.getKey())); + assertEquals(Access.AccessTags.DESIGNATED.getKey(), + mergedMaps.getOrDefault(Access.AccessTags.HGV.getKey(), Access.AccessTags.NO.getKey())); + assertEquals(Access.AccessTags.DESIGNATED.getKey(), + mergedMaps.getOrDefault(Access.AccessTags.HGV_ARTICULATED.getKey(), Access.AccessTags.NO.getKey())); + } +}