Somehow the code in UCD.java becomes a little bit cleaner

Author: eggrobin

unicodetools/src/main/java/org/unicode/props/IndexUnicodeProperties.java

@@ -28,6 +28,7 @@
 import java.util.EnumMap;
 import java.util.EnumSet;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Locale;
@@ -839,11 +840,21 @@ public List<String> _getNameAliases(List result) {
         }
 
         @Override
-        protected List<String> _getAvailableValues(List result) {
+        protected List<String> _getAvailableValues(List<String> result) {
             if (stringToNamedEnum != null) {
                 result.addAll(enumValueNames);
                 return result;
             }
+            if (isMultivalued()) {
+                HashSet<String> valueSet = new HashSet<>();
+                for (var value : _getUnicodeMap().getAvailableValues()) {
+                    for (var part : delimiterSplitter.split(value)) {
+                        valueSet.add(part);
+                    }
+                }
+                result.addAll(valueSet);
+                return result;
+            }
             return _getUnicodeMap().getAvailableValues(result);
         }
 

unicodetools/src/main/java/org/unicode/props/UnicodeProperty.java

@@ -20,6 +20,7 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -157,7 +158,7 @@ public static synchronized void ResetCacheProperties() {
     private boolean isMultivalued = false;
 
     private String delimiter = ",";
-    private Splitter delimiterSplitter = Splitter.on(delimiter);
+    protected Splitter delimiterSplitter = Splitter.on(delimiter);
 
     public UnicodeProperty setMultivalued(boolean value) {
         isMultivalued = value;
@@ -263,6 +264,12 @@ public String getVersion() {
         return _getVersion();
     }
 
+    public Iterable<String> getValues(int codepoint) {
+        return isMultivalued
+                ? delimiterSplitter.split(getValue(codepoint))
+                : Collections.singleton(getValue(codepoint));
+    }
+
     public String getValue(int codepoint) {
         if (DEBUG && CHECK_VALUE == codepoint && CHECK_NAME.equals(getName())) {
             String value = _getValue(codepoint);
@@ -290,8 +297,10 @@ public List<String> getValueAliases(String valueAlias, List<String> result) {
         if (result == null) result = new ArrayList<>(1);
         result = _getValueAliases(valueAlias, result);
         if (!result.contains(valueAlias)) { // FIX && type < NUMERIC
-            if (type == MISC) {
+            if (type == MISC || type == NUMERIC) {
                 // Unihan has multivalued properties but does not use aliases.
+                // The concept of aliases does not really apply to numeric properties,
+                // but we should apply UAX44-LM1.  We don’t, though.
                 result.add(valueAlias);
             } else {
                 result = _getValueAliases(valueAlias, result); // for debugging

unicodetools/src/main/java/org/unicode/text/UCD/UCD.java

@@ -522,41 +522,28 @@ static class HanException {
     }
 
     private void populateHanExceptions(UnicodeProperty numeric) {
-        for (String value : numeric.getAvailableValues()) {
-            if (value == null || value.equals("NaN")) {
-                continue;
-            }
-            String propertyValue = Utility.replace(value, ",", "");
-            final int hack = propertyValue.indexOf(' ');
-            if (hack >= 0) {
-                Utility.fixDot();
-                if (SHOW_LOADING) {
-                    System.out.println("BAD NUMBER: " + value);
-                }
-                propertyValue = propertyValue.substring(0, hack);
-            }
-
-            for (String s : numeric.getSet(value)) {
-                final int code = s.codePointAt(0);
-                // Unicode 15.1:
-                // This code had these two exceptions, but now U+4EAC actually has value
-                // 10000000000000000
-                // and we want to see that in DerivedNumericValues.txt,
-                // so we stop making these exceptions.
-                if (compositeVersion < 0xf0100 && (code == 0x5793 || code == 0x4EAC)) {
-                    continue; // two exceptions!!
-                }
-
-                HanException except = (HanException) hanExceptions.get(code);
-                if (except != null) {
-                    throw new IllegalArgumentException(
-                            "Duplicate Numeric Value for U+" + Utility.hex(code));
-                }
-                except = new HanException();
-                hanExceptions.put(code, except);
-                except.numericValue = Double.parseDouble(propertyValue);
-                except.numericType = NUMERIC;
+        for (final int code : numeric.getSet("NaN").complement().codePoints()) {
+            // Unicode 15.1:
+            // This code had these two exceptions, but now U+4EAC actually has value
+            // 10000000000000000
+            // and we want to see that in DerivedNumericValues.txt,
+            // so we stop making these exceptions.
+            // NOTE(egg): These two exceptions (we are in a function called exceptions, so these are
+            // exceptions to the broader exception that is Han numeric values) were made irrelevant
+            // sometime before Unicode 5.2.  See L2/03-094 for background.
+            if (compositeVersion < 0xf0100 && (code == 0x5793 || code == 0x4EAC)) {
+                continue; // two exceptions!!
+            }
+
+            HanException except = (HanException) hanExceptions.get(code);
+            if (except != null && false) {
+                throw new IllegalArgumentException(
+                        "Duplicate Numeric Value for U+" + Utility.hex(code));
             }
+            except = new HanException();
+            hanExceptions.put(code, except);
+            except.numericValue = Double.parseDouble(numeric.getValues(code).iterator().next());
+            except.numericType = NUMERIC;
         }
     }