xref: /aosp_15_r20/external/cldr/tools/cldr-code/src/main/java/org/unicode/cldr/util/CLDRFile.java (revision 912701f9769bb47905792267661f0baf2b85bed5)

/*
 **********************************************************************
 * Copyright (c) 2002-2019, International Business Machines
 * Corporation and others.  All Rights Reserved.
 **********************************************************************
 * Author: Mark Davis
 **********************************************************************
 */
package org.unicode.cldr.util;

import com.google.common.base.Joiner;
import com.google.common.base.Splitter;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableMap.Builder;
import com.google.common.collect.ImmutableSet;
import com.google.common.util.concurrent.UncheckedExecutionException;
import com.ibm.icu.impl.Relation;
import com.ibm.icu.impl.Row;
import com.ibm.icu.impl.Row.R2;
import com.ibm.icu.impl.Utility;
import com.ibm.icu.text.MessageFormat;
import com.ibm.icu.text.PluralRules;
import com.ibm.icu.text.SimpleDateFormat;
import com.ibm.icu.text.Transform;
import com.ibm.icu.text.UnicodeSet;
import com.ibm.icu.util.Calendar;
import com.ibm.icu.util.Freezable;
import com.ibm.icu.util.ICUUncheckedIOException;
import com.ibm.icu.util.Output;
import com.ibm.icu.util.ULocale;
import com.ibm.icu.util.VersionInfo;
import java.io.File;
import java.io.FileInputStream;
import java.io.FilenameFilter;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.concurrent.ConcurrentHashMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import org.unicode.cldr.test.CheckMetazones;
import org.unicode.cldr.util.DayPeriodInfo.DayPeriod;
import org.unicode.cldr.util.GrammarInfo.GrammaticalFeature;
import org.unicode.cldr.util.GrammarInfo.GrammaticalScope;
import org.unicode.cldr.util.GrammarInfo.GrammaticalTarget;
import org.unicode.cldr.util.LocaleInheritanceInfo.Reason;
import org.unicode.cldr.util.SupplementalDataInfo.PluralInfo;
import org.unicode.cldr.util.SupplementalDataInfo.PluralInfo.Count;
import org.unicode.cldr.util.SupplementalDataInfo.PluralType;
import org.unicode.cldr.util.With.SimpleIterator;
import org.unicode.cldr.util.XMLFileReader.AllHandler;
import org.unicode.cldr.util.XMLSource.ResolvingSource;
import org.unicode.cldr.util.XPathParts.Comments;
import org.xml.sax.Attributes;
import org.xml.sax.Locator;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
import org.xml.sax.XMLReader;
import org.xml.sax.helpers.XMLReaderFactory;

/**
 * This is a class that represents the contents of a CLDR file, as <key,value> pairs, where the key
 * is a "cleaned" xpath (with non-distinguishing attributes removed), and the value is an object
 * that contains the full xpath plus a value, which is a string, or a node (the latter for atomic
 * elements).
 *
 * <p><b>WARNING: The API on this class is likely to change.</b> Having the full xpath on the value
 * is clumsy; I need to change it to having the key be an object that contains the full xpath, but
 * then sorts as if it were clean.
 *
 * <p>Each instance also contains a set of associated comments for each xpath.
 *
 * @author medavis
 */

/*
 * Notes:
 * http://xml.apache.org/xerces2-j/faq-grammars.html#faq-3
 * http://developers.sun.com/dev/coolstuff/xml/readme.html
 * http://lists.xml.org/archives/xml-dev/200007/msg00284.html
 * http://java.sun.com/j2se/1.4.2/docs/api/org/xml/sax/DTDHandler.html
 */

public class CLDRFile implements Freezable<CLDRFile>, Iterable<String>, LocaleStringProvider {

    private static final String GETNAME_LOCALE_SEPARATOR =
            "//ldml/localeDisplayNames/localeDisplayPattern/localeSeparator";
    private static final String GETNAME_LOCALE_PATTERN =
            "//ldml/localeDisplayNames/localeDisplayPattern/localePattern";
    private static final String GETNAME_LOCALE_KEY_TYPE_PATTERN =
            "//ldml/localeDisplayNames/localeDisplayPattern/localeKeyTypePattern";

    private static final ImmutableSet<String> casesNominativeOnly =
            ImmutableSet.of(GrammaticalFeature.grammaticalCase.getDefault(null));
    /**
     * Variable to control whether File reads are buffered; this will about halve the time spent in
     * loadFromFile() and Factory.make() from about 20 % to about 10 %. It will also noticeably
     * improve the different unit tests take in the TestAll fixture. TRUE - use buffering (default)
     * FALSE - do not use buffering
     */
    private static final boolean USE_LOADING_BUFFER = true;

    private static final boolean DEBUG = false;

    public static final Pattern ALT_PROPOSED_PATTERN =
            PatternCache.get(".*\\[@alt=\"[^\"]*proposed[^\"]*\"].*");
    public static final Pattern DRAFT_PATTERN = PatternCache.get("\\[@draft=\"([^\"]*)\"\\]");
    public static final Pattern XML_SPACE_PATTERN =
            PatternCache.get("\\[@xml:space=\"([^\"]*)\"\\]");

    private static boolean LOG_PROGRESS = false;

    public static boolean HACK_ORDER = false;
    private static boolean DEBUG_LOGGING = false;

    public static final String SUPPLEMENTAL_NAME = "supplementalData";
    public static final String SUPPLEMENTAL_METADATA = "supplementalMetadata";
    public static final String SUPPLEMENTAL_PREFIX = "supplemental";
    public static final String GEN_VERSION = "45";
    public static final List<String> SUPPLEMENTAL_NAMES =
            Arrays.asList(
                    "characters",
                    "coverageLevels",
                    "dayPeriods",
                    "genderList",
                    "grammaticalFeatures",
                    "languageInfo",
                    "languageGroup",
                    "likelySubtags",
                    "metaZones",
                    "numberingSystems",
                    "ordinals",
                    "pluralRanges",
                    "plurals",
                    "postalCodeData",
                    "rgScope",
                    "supplementalData",
                    "supplementalMetadata",
                    "telephoneCodeData",
                    "units",
                    "windowsZones");

    private Set<String> extraPaths = null;

    private boolean locked;
    private DtdType dtdType;
    private DtdData dtdData;

    XMLSource dataSource; // TODO(jchye): make private

    private File supplementalDirectory;

    /**
     * Does the value in question either match or inherent the current value?
     *
     * <p>To match, the value in question and the current value must be non-null and equal.
     *
     * <p>To inherit the current value, the value in question must be INHERITANCE_MARKER and the
     * current value must equal the bailey value.
     *
     * <p>This CLDRFile is only used here for getBaileyValue, not to get curValue
     *
     * @param value the value in question
     * @param curValue the current value, that is, XMLSource.getValueAtDPath(xpathString)
     * @param xpathString the path identifier
     * @return true if it matches or inherits, else false
     */
    public boolean equalsOrInheritsCurrentValue(String value, String curValue, String xpathString) {
        if (value == null || curValue == null) {
            return false;
        }
        if (value.equals(curValue)) {
            return true;
        }
        if (value.equals(CldrUtility.INHERITANCE_MARKER)) {
            String baileyValue = getBaileyValue(xpathString, null, null);
            if (baileyValue == null) {
                /* This may happen for Invalid XPath; InvalidXPathException may be thrown. */
                return false;
            }
            if (curValue.equals(baileyValue)) {
                return true;
            }
        }
        return false;
    }

    public XMLSource getResolvingDataSource() {
        if (!isResolved()) {
            throw new IllegalArgumentException(
                    "CLDRFile must be resolved for getResolvingDataSource");
        }
        // dataSource instanceof XMLSource.ResolvingSource
        return dataSource;
    }

    public enum DraftStatus {
        unconfirmed,
        provisional,
        contributed,
        approved;

        public static DraftStatus forString(String string) {
            return string == null
                    ? DraftStatus.approved
                    : DraftStatus.valueOf(string.toLowerCase(Locale.ENGLISH));
        }

        /**
         * Get the draft status from a full xpath
         *
         * @param xpath
         * @return
         */
        public static DraftStatus forXpath(String xpath) {
            final String status =
                    XPathParts.getFrozenInstance(xpath).getAttributeValue(-1, "draft");
            return forString(status);
        }

        /** Return the XPath suffix for this draft status or "" for approved. */
        public String asXpath() {
            if (this == approved) {
                return "";
            } else {
                return "[@draft=\"" + name() + "\"]";
            }
        }

        /** update this XPath with this draft status */
        public String updateXPath(final String fullXpath) {
            final XPathParts xpp = XPathParts.getFrozenInstance(fullXpath).cloneAsThawed();
            final String oldDraft = xpp.getAttributeValue(-1, "draft");
            if (forString(oldDraft) == this) {
                return fullXpath; // no change;
            }
            if (this == approved) {
                xpp.removeAttribute(-1, "draft");
            } else {
                xpp.setAttribute(-1, "draft", this.name());
            }
            return xpp.toString();
        }
    }

    @Override
    public String toString() {
        return "{"
                + "locked="
                + locked
                + " locale="
                + dataSource.getLocaleID()
                + " dataSource="
                + dataSource.toString()
                + "}";
    }

    public String toString(String regex) {
        return "{"
                + "locked="
                + locked
                + " locale="
                + dataSource.getLocaleID()
                + " regex="
                + regex
                + " dataSource="
                + dataSource.toString(regex)
                + "}";
    }

    // for refactoring

    public CLDRFile setNonInheriting(boolean isSupplemental) {
        if (locked) {
            throw new UnsupportedOperationException("Attempt to modify locked object");
        }
        dataSource.setNonInheriting(isSupplemental);
        return this;
    }

    public boolean isNonInheriting() {
        return dataSource.isNonInheriting();
    }

    private static final boolean DEBUG_CLDR_FILE = false;
    private String creationTime = null; // only used if DEBUG_CLDR_FILE

    /**
     * Construct a new CLDRFile.
     *
     * @param dataSource must not be null
     */
    public CLDRFile(XMLSource dataSource) {
        this.dataSource = dataSource;

        if (DEBUG_CLDR_FILE) {
            creationTime =
                    new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'")
                            .format(Calendar.getInstance().getTime());
            System.out.println("�� Created new CLDRFile(dataSource) at " + creationTime);
        }
    }

    /**
     * get Unresolved CLDRFile
     *
     * @param localeId
     * @param dirs
     * @param minimalDraftStatus
     */
    public CLDRFile(String localeId, List<File> dirs, DraftStatus minimalDraftStatus) {
        // order matters
        this.dataSource = XMLSource.getFrozenInstance(localeId, dirs, minimalDraftStatus);
        this.dtdType = dataSource.getXMLNormalizingDtdType();
        this.dtdData = DtdData.getInstance(this.dtdType);
    }

    public CLDRFile(XMLSource dataSource, XMLSource... resolvingParents) {
        List<XMLSource> sourceList = new ArrayList<>();
        sourceList.add(dataSource);
        sourceList.addAll(Arrays.asList(resolvingParents));
        this.dataSource = new ResolvingSource(sourceList);

        if (DEBUG_CLDR_FILE) {
            creationTime =
                    new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'")
                            .format(Calendar.getInstance().getTime());
            System.out.println(
                    "�� Created new CLDRFile(dataSource, XMLSource... resolvingParents) at "
                            + creationTime);
        }
    }

    public static CLDRFile loadFromFile(
            File f, String localeName, DraftStatus minimalDraftStatus, XMLSource source) {
        String fullFileName = f.getAbsolutePath();
        try {
            fullFileName = PathUtilities.getNormalizedPathString(f);
            if (DEBUG_LOGGING) {
                System.out.println("Parsing: " + fullFileName);
                Log.logln(LOG_PROGRESS, "Parsing: " + fullFileName);
            }
            final CLDRFile cldrFile;
            if (USE_LOADING_BUFFER) {
                // Use Buffering -  improves performance at little cost to memory footprint
                // try (InputStream fis = new BufferedInputStream(new FileInputStream(f),32000);) {
                try (InputStream fis = InputStreamFactory.createInputStream(f)) {
                    cldrFile = load(fullFileName, localeName, fis, minimalDraftStatus, source);
                    return cldrFile;
                }
            } else {
                // previous version - do not use buffering
                try (InputStream fis = new FileInputStream(f); ) {
                    cldrFile = load(fullFileName, localeName, fis, minimalDraftStatus, source);
                    return cldrFile;
                }
            }

        } catch (Exception e) {
            // use a StringBuilder to construct the message.
            StringBuilder sb = new StringBuilder("Cannot read the file '");
            sb.append(fullFileName);
            sb.append("': ");
            sb.append(e.getMessage());
            throw new ICUUncheckedIOException(sb.toString(), e);
        }
    }

    public static CLDRFile loadFromFiles(
            List<File> dirs, String localeName, DraftStatus minimalDraftStatus, XMLSource source) {
        try {
            if (DEBUG_LOGGING) {
                System.out.println("Parsing: " + dirs);
                Log.logln(LOG_PROGRESS, "Parsing: " + dirs);
            }
            if (USE_LOADING_BUFFER) {
                // Use Buffering -  improves performance at little cost to memory footprint
                // try (InputStream fis = new BufferedInputStream(new FileInputStream(f),32000);) {
                CLDRFile cldrFile = new CLDRFile(source);
                for (File dir : dirs) {
                    File f = new File(dir, localeName + ".xml");
                    try (InputStream fis = InputStreamFactory.createInputStream(f)) {
                        cldrFile.loadFromInputStream(
                                PathUtilities.getNormalizedPathString(f),
                                localeName,
                                fis,
                                minimalDraftStatus,
                                false);
                    }
                }
                return cldrFile;
            } else {
                throw new IllegalArgumentException("Must use USE_LOADING_BUFFER");
            }

        } catch (Exception e) {
            // e.printStackTrace();
            // use a StringBuilder to construct the message.
            StringBuilder sb = new StringBuilder("Cannot read the file '");
            sb.append(dirs);
            throw new ICUUncheckedIOException(sb.toString(), e);
        }
    }

    /**
     * Produce a CLDRFile from a localeName, given a directory. (Normally a Factory is used to
     * create CLDRFiles.)
     *
     * @param f
     * @param localeName
     * @param minimalDraftStatus
     */
    public static CLDRFile loadFromFile(File f, String localeName, DraftStatus minimalDraftStatus) {
        return loadFromFile(f, localeName, minimalDraftStatus, new SimpleXMLSource(localeName));
    }

    public static CLDRFile loadFromFiles(
            List<File> dirs, String localeName, DraftStatus minimalDraftStatus) {
        return loadFromFiles(dirs, localeName, minimalDraftStatus, new SimpleXMLSource(localeName));
    }

    static CLDRFile load(
            String fileName, String localeName, InputStream fis, DraftStatus minimalDraftStatus) {
        return load(fileName, localeName, fis, minimalDraftStatus, new SimpleXMLSource(localeName));
    }

    /**
     * Load a CLDRFile from a file input stream.
     *
     * @param localeName
     * @param fis
     */
    private static CLDRFile load(
            String fileName,
            String localeName,
            InputStream fis,
            DraftStatus minimalDraftStatus,
            XMLSource source) {
        CLDRFile cldrFile = new CLDRFile(source);
        return cldrFile.loadFromInputStream(fileName, localeName, fis, minimalDraftStatus, false);
    }

    /**
     * Load a CLDRFile from a file input stream.
     *
     * @param localeName
     * @param fis
     */
    private static CLDRFile load(
            String fileName,
            String localeName,
            InputStream fis,
            DraftStatus minimalDraftStatus,
            XMLSource source,
            boolean leniency) {
        CLDRFile cldrFile = new CLDRFile(source);
        return cldrFile.loadFromInputStream(
                fileName, localeName, fis, minimalDraftStatus, leniency);
    }

    static CLDRFile load(
            String fileName,
            String localeName,
            InputStream fis,
            DraftStatus minimalDraftStatus,
            boolean leniency) {
        return load(
                fileName,
                localeName,
                fis,
                minimalDraftStatus,
                new SimpleXMLSource(localeName),
                leniency);
    }

    /**
     * Low-level function, only normally used for testing.
     *
     * @param fileName
     * @param localeName
     * @param fis
     * @param minimalDraftStatus
     * @param leniency if true, skip dtd validation
     * @return
     */
    public CLDRFile loadFromInputStream(
            String fileName,
            String localeName,
            InputStream fis,
            DraftStatus minimalDraftStatus,
            boolean leniency) {
        CLDRFile cldrFile = this;
        MyDeclHandler DEFAULT_DECLHANDLER = new MyDeclHandler(cldrFile, minimalDraftStatus);
        XMLFileReader.read(fileName, fis, -1, !leniency, DEFAULT_DECLHANDLER);
        if (DEFAULT_DECLHANDLER.isSupplemental < 0) {
            throw new IllegalArgumentException(
                    "root of file must be either ldml or supplementalData");
        }
        cldrFile.setNonInheriting(DEFAULT_DECLHANDLER.isSupplemental > 0);
        if (DEFAULT_DECLHANDLER.overrideCount > 0) {
            throw new IllegalArgumentException(
                    "Internal problems: either data file has duplicate path, or"
                            + " CLDRFile.isDistinguishing() or CLDRFile.isOrdered() need updating: "
                            + DEFAULT_DECLHANDLER.overrideCount
                            + "; The exact problems are printed on the console above.");
        }
        if (localeName == null) {
            cldrFile.dataSource.setLocaleID(cldrFile.getLocaleIDFromIdentity());
        }
        return cldrFile;
    }

    /**
     * Clone the object. Produces unlocked version
     *
     * @see com.ibm.icu.util.Freezable
     */
    @Override
    public CLDRFile cloneAsThawed() {
        try {
            CLDRFile result = (CLDRFile) super.clone();
            result.locked = false;
            result.dataSource = result.dataSource.cloneAsThawed();
            return result;
        } catch (CloneNotSupportedException e) {
            throw new InternalError("should never happen");
        }
    }

    /** Prints the contents of the file (the xpaths/values) to the console. */
    public CLDRFile show() {
        for (Iterator<String> it2 = iterator(); it2.hasNext(); ) {
            String xpath = it2.next();
            System.out.println(getFullXPath(xpath) + " =>\t" + getStringValue(xpath));
        }
        return this;
    }

    private static final Map<String, Object> nullOptions =
            Collections.unmodifiableMap(new TreeMap<String, Object>());

    /**
     * Write the corresponding XML file out, with the normal formatting and indentation. Will update
     * the identity element, including version, and other items. If the CLDRFile is empty, the DTD
     * type will be //ldml.
     */
    public void write(PrintWriter pw) {
        write(pw, nullOptions);
    }

    /**
     * Write the corresponding XML file out, with the normal formatting and indentation. Will update
     * the identity element, including version, and other items. If the CLDRFile is empty, the DTD
     * type will be //ldml.
     *
     * @param pw writer to print to
     * @param options map of options for writing
     * @return true if we write the file, false if we cancel due to skipping all paths
     */
    public boolean write(PrintWriter pw, Map<String, ?> options) {
        final CldrXmlWriter xmlWriter = new CldrXmlWriter(this, pw, options);
        xmlWriter.write();
        return true;
    }

    /** Get a string value from an xpath. */
    @Override
    public String getStringValue(String xpath) {
        try {
            String result = dataSource.getValueAtPath(xpath);
            if (result == null && dataSource.isResolving()) {
                final String fallbackPath = getFallbackPath(xpath, false, true);
                // often fallbackPath equals xpath -- in such cases, isn't it a waste of time to
                // call getValueAtPath again?
                if (fallbackPath != null) {
                    result = dataSource.getValueAtPath(fallbackPath);
                }
            }
            if (isResolved()
                    && GlossonymConstructor.valueIsBogus(result)
                    && GlossonymConstructor.pathIsEligible(xpath)) {
                final String constructedValue = new GlossonymConstructor(this).getValue(xpath);
                if (constructedValue != null) {
                    result = constructedValue;
                }
            }
            return result;
        } catch (Exception e) {
            throw new UncheckedExecutionException("Bad path: " + xpath, e);
        }
    }

    /**
     * Get GeorgeBailey value: that is, what the value would be if it were not directly contained in
     * the file at that path. If the value is null or INHERITANCE_MARKER (with resolving), then
     * baileyValue = resolved value. A non-resolving CLDRFile will always return null.
     */
    public String getBaileyValue(
            String xpath, Output<String> pathWhereFound, Output<String> localeWhereFound) {
        String result = dataSource.getBaileyValue(xpath, pathWhereFound, localeWhereFound);
        if ((result == null || result.equals(CldrUtility.INHERITANCE_MARKER))
                && dataSource.isResolving()) {
            final String fallbackPath =
                    getFallbackPath(
                            xpath, false,
                            false); // return null if there is no different sideways path
            if (xpath.equals(fallbackPath)) {
                getFallbackPath(xpath, false, true);
                throw new IllegalArgumentException(); // should never happen
            }
            if (fallbackPath != null) {
                result = dataSource.getValueAtPath(fallbackPath);
                if (result != null) {
                    Status status = new Status();
                    if (localeWhereFound != null) {
                        localeWhereFound.value = dataSource.getSourceLocaleID(fallbackPath, status);
                    }
                    if (pathWhereFound != null) {
                        pathWhereFound.value = status.pathWhereFound;
                    }
                }
            }
        }
        if (isResolved()
                && GlossonymConstructor.valueIsBogus(result)
                && GlossonymConstructor.pathIsEligible(xpath)) {
            final GlossonymConstructor gc = new GlossonymConstructor(this);
            final String constructedValue =
                    gc.getValueAndTrack(xpath, pathWhereFound, localeWhereFound);
            if (constructedValue != null) {
                result = constructedValue;
            }
        }
        return result;
    }

    /**
     * Return a list of all paths which contributed to the value, as well as all bailey values. This
     * is used to explain inheritance and bailey values. The list must be interpreted in order. When
     * {@link LocaleInheritanceInfo.Reason#isTerminal()} return true, that indicates a successful
     * lookup and partitions values from subsequent bailey values.
     *
     * @see #getBaileyValue(String, Output, Output)
     * @see #getSourceLocaleIdExtended(String, Status, boolean)
     */
    public List<LocaleInheritanceInfo> getPathsWhereFound(String xpath) {
        if (!isResolved()) {
            throw new IllegalArgumentException(
                    "getPathsWhereFound() is only valid on a resolved CLDRFile");
        }
        LinkedList<LocaleInheritanceInfo> list = new LinkedList<>();
        // first, call getSourceLocaleIdExtended to populate the list
        Status status = new Status();
        getSourceLocaleIdExtended(xpath, status, false, list);
        final String path1 = status.pathWhereFound;
        // For now, the only special case is Glossonym
        if (path1.equals(GlossonymConstructor.PSEUDO_PATH)) {
            // it's a Glossonym, so as the GlossonymConstructor what the paths are.  Sort paths in
            // reverse order.
            final Set<String> xpaths =
                    new GlossonymConstructor(this)
                            .getPathsWhereFound(
                                    xpath, new TreeSet<String>(Comparator.reverseOrder()));
            for (final String subpath : xpaths) {
                final String locale2 = getSourceLocaleIdExtended(subpath, status, true);
                final String path2 = status.pathWhereFound;
                // Paths are in reverse order (c-b-a) so we insert them at the top of our list.
                list.addFirst(new LocaleInheritanceInfo(locale2, path2, Reason.constructed));
            }

            // now the list contains:
            // constructed: a
            // constructed: b
            // constructed: c
            // (none) - this is where the glossonym was
            // (bailey value(s))
        }
        return list;
    }

    static final class SimpleAltPicker implements Transform<String, String> {
        public final String alt;

        public SimpleAltPicker(String alt) {
            this.alt = alt;
        }

        @Override
        public String transform(@SuppressWarnings("unused") String source) {
            return alt;
        }
    }

    /**
     * Only call if xpath doesn't exist in the current file.
     *
     * <p>For now, just handle counts and cases: see getCountPath Also handle extraPaths
     *
     * @param xpath
     * @param winning TODO
     * @param checkExtraPaths TODO
     * @return
     */
    private String getFallbackPath(String xpath, boolean winning, boolean checkExtraPaths) {
        if (GrammaticalFeature.pathHasFeature(xpath) != null) {
            return getCountPathWithFallback(xpath, Count.other, winning);
        }
        if (checkExtraPaths && getRawExtraPaths().contains(xpath)) {
            return xpath;
        }
        return null;
    }

    /**
     * Get the full path from a distinguished path.
     *
     * @param xpath the distinguished path
     * @return the full path
     *     <p>Examples:
     *     <p>xpath = //ldml/localeDisplayNames/scripts/script[@type="Adlm"] result =
     *     //ldml/localeDisplayNames/scripts/script[@type="Adlm"][@draft="unconfirmed"]
     *     <p>xpath =
     *     //ldml/dates/calendars/calendar[@type="hebrew"]/dateFormats/dateFormatLength[@type="full"]/dateFormat[@type="standard"]/pattern[@type="standard"]
     *     result =
     *     //ldml/dates/calendars/calendar[@type="hebrew"]/dateFormats/dateFormatLength[@type="full"]/dateFormat[@type="standard"]/pattern[@type="standard"][@numbers="hebr"]
     */
    public String getFullXPath(String xpath) {
        if (xpath == null) {
            throw new NullPointerException("Null distinguishing xpath");
        }
        String result = dataSource.getFullPath(xpath);
        return result != null
                ? result
                : xpath; // we can't add any non-distinguishing values if there is nothing there.
        //        if (result == null && dataSource.isResolving()) {
        //            String fallback = getFallbackPath(xpath, true);
        //            if (fallback != null) {
        //                // TODO, add attributes from fallback into main
        //                result = xpath;
        //            }
        //        }
        //        return result;
    }

    /**
     * Get the last modified date (if available) from a distinguished path.
     *
     * @return date or null if not available.
     */
    public Date getLastModifiedDate(String xpath) {
        return dataSource.getChangeDateAtDPath(xpath);
    }

    /**
     * Find out where the value was found (for resolving locales). Returns {@link
     * XMLSource#CODE_FALLBACK_ID} as the location if nothing is found
     *
     * @param distinguishedXPath path (must be distinguished!)
     * @param status the distinguished path where the item was found. Pass in null if you don't
     *     care.
     */
    @Override
    public String getSourceLocaleID(String distinguishedXPath, CLDRFile.Status status) {
        return getSourceLocaleIdExtended(
                distinguishedXPath, status, true /* skipInheritanceMarker */);
    }

    /**
     * Find out where the value was found (for resolving locales). Returns {@link
     * XMLSource#CODE_FALLBACK_ID} as the location if nothing is found
     *
     * @param distinguishedXPath path (must be distinguished!)
     * @param status the distinguished path where the item was found. Pass in null if you don't
     *     care.
     * @param skipInheritanceMarker if true, skip sources in which value is INHERITANCE_MARKER
     * @return the locale id as a string
     */
    public String getSourceLocaleIdExtended(
            String distinguishedXPath, CLDRFile.Status status, boolean skipInheritanceMarker) {
        return getSourceLocaleIdExtended(distinguishedXPath, status, skipInheritanceMarker, null);
    }

    public String getSourceLocaleIdExtended(
            String distinguishedXPath,
            CLDRFile.Status status,
            boolean skipInheritanceMarker,
            List<LocaleInheritanceInfo> list) {
        String result =
                dataSource.getSourceLocaleIdExtended(
                        distinguishedXPath, status, skipInheritanceMarker, list);
        if (result == XMLSource.CODE_FALLBACK_ID && dataSource.isResolving()) {
            final String fallbackPath = getFallbackPath(distinguishedXPath, false, true);
            if (fallbackPath != null && !fallbackPath.equals(distinguishedXPath)) {
                if (list != null) {
                    list.add(
                            new LocaleInheritanceInfo(
                                    getLocaleID(), distinguishedXPath, Reason.fallback, null));
                }
                result =
                        dataSource.getSourceLocaleIdExtended(
                                fallbackPath, status, skipInheritanceMarker, list);
            }
            if (result == XMLSource.CODE_FALLBACK_ID
                    && getConstructedValue(distinguishedXPath) != null) {
                if (status != null) {
                    status.pathWhereFound = GlossonymConstructor.PSEUDO_PATH;
                }
                return getLocaleID();
            }
        }
        return result;
    }

    /**
     * return true if the path in this file (without resolution)
     *
     * @param path
     * @return
     */
    public boolean isHere(String path) {
        return dataSource.isHere(path);
    }

    /**
     * Add a new element to a CLDRFile.
     *
     * @param currentFullXPath
     * @param value
     */
    public CLDRFile add(String currentFullXPath, String value) {
        if (locked) throw new UnsupportedOperationException("Attempt to modify locked object");
        // StringValue v = new StringValue(value, currentFullXPath);
        Log.logln(
                LOG_PROGRESS,
                "ADDING: \t" + currentFullXPath + " \t" + value + "\t" + currentFullXPath);
        // xpath = xpath.intern();
        try {
            dataSource.putValueAtPath(currentFullXPath, value);
        } catch (RuntimeException e) {
            throw (IllegalArgumentException)
                    new IllegalArgumentException(
                                    "failed adding " + currentFullXPath + ",\t" + value)
                            .initCause(e);
        }
        return this;
    }

    /** Note where this element was parsed. */
    public CLDRFile addSourceLocation(String currentFullXPath, XMLSource.SourceLocation location) {
        dataSource.addSourceLocation(currentFullXPath, location);
        return this;
    }

    /**
     * Get the line and column for a path
     *
     * @param path xpath or fullpath
     */
    public XMLSource.SourceLocation getSourceLocation(String path) {
        final String fullPath = getFullXPath(path);
        return dataSource.getSourceLocation(fullPath);
    }

    public CLDRFile addComment(String xpath, String comment, Comments.CommentType type) {
        if (locked) throw new UnsupportedOperationException("Attempt to modify locked object");
        // System.out.println("Adding comment: <" + xpath + "> '" + comment + "'");
        Log.logln(LOG_PROGRESS, "ADDING Comment: \t" + type + "\t" + xpath + " \t" + comment);
        if (xpath == null || xpath.length() == 0) {
            dataSource
                    .getXpathComments()
                    .setFinalComment(
                            CldrUtility.joinWithSeparation(
                                    dataSource.getXpathComments().getFinalComment(),
                                    XPathParts.NEWLINE,
                                    comment));
        } else {
            xpath = getDistinguishingXPath(xpath, null);
            dataSource.getXpathComments().addComment(type, xpath, comment);
        }
        return this;
    }

    // TODO Change into enum, update docs
    public static final int MERGE_KEEP_MINE = 0,
            MERGE_REPLACE_MINE = 1,
            MERGE_ADD_ALTERNATE = 2,
            MERGE_REPLACE_MY_DRAFT = 3;

    /**
     * Merges elements from another CLDR file. Note: when both have the same xpath key, the keepMine
     * determines whether "my" values are kept or the other files values are kept.
     *
     * @param other
     * @param conflict_resolution
     */
    public CLDRFile putAll(CLDRFile other, int conflict_resolution) {

        if (locked) {
            throw new UnsupportedOperationException("Attempt to modify locked object");
        }
        if (conflict_resolution == MERGE_KEEP_MINE) {
            dataSource.putAll(other.dataSource, MERGE_KEEP_MINE);
        } else if (conflict_resolution == MERGE_REPLACE_MINE) {
            dataSource.putAll(other.dataSource, MERGE_REPLACE_MINE);
        } else if (conflict_resolution == MERGE_REPLACE_MY_DRAFT) {
            // first find all my alt=..proposed items
            Set<String> hasDraftVersion = new HashSet<>();
            for (Iterator<String> it = dataSource.iterator(); it.hasNext(); ) {
                String cpath = it.next();
                String fullpath = getFullXPath(cpath);
                if (fullpath.indexOf("[@draft") >= 0) {
                    hasDraftVersion.add(
                            getNondraftNonaltXPath(cpath)); // strips the alt and the draft
                }
            }
            // only replace draft items!
            // this is either an item with draft in the fullpath
            // or an item with draft and alt in the full path
            for (Iterator<String> it = other.iterator(); it.hasNext(); ) {
                String cpath = it.next();
                cpath = getNondraftNonaltXPath(cpath);
                String newValue = other.getStringValue(cpath);
                String newFullPath = getNondraftNonaltXPath(other.getFullXPath(cpath));
                // another hack; need to add references back in
                newFullPath = addReferencesIfNeeded(newFullPath, getFullXPath(cpath));

                if (!hasDraftVersion.contains(cpath)) {
                    if (cpath.startsWith("//ldml/identity/"))
                        continue; // skip, since the error msg is not needed.
                    String myVersion = getStringValue(cpath);
                    if (myVersion == null || !newValue.equals(myVersion)) {
                        Log.logln(
                                getLocaleID()
                                        + "\tDenied attempt to replace non-draft"
                                        + CldrUtility.LINE_SEPARATOR
                                        + "\tcurr: ["
                                        + cpath
                                        + ",\t"
                                        + myVersion
                                        + "]"
                                        + CldrUtility.LINE_SEPARATOR
                                        + "\twith: ["
                                        + newValue
                                        + "]");
                        continue;
                    }
                }
                Log.logln(getLocaleID() + "\tVETTED: [" + newFullPath + ",\t" + newValue + "]");
                dataSource.putValueAtPath(newFullPath, newValue);
            }
        } else if (conflict_resolution == MERGE_ADD_ALTERNATE) {
            for (Iterator<String> it = other.iterator(); it.hasNext(); ) {
                String key = it.next();
                String otherValue = other.getStringValue(key);
                String myValue = dataSource.getValueAtPath(key);
                if (myValue == null) {
                    dataSource.putValueAtPath(other.getFullXPath(key), otherValue);
                } else if (!(myValue.equals(otherValue)
                                && equalsIgnoringDraft(getFullXPath(key), other.getFullXPath(key)))
                        && !key.startsWith("//ldml/identity")) {
                    for (int i = 0; ; ++i) {
                        String prop = "proposed" + (i == 0 ? "" : String.valueOf(i));
                        XPathParts parts =
                                XPathParts.getFrozenInstance(other.getFullXPath(key))
                                        .cloneAsThawed(); // not frozen, for addAttribut
                        String fullPath = parts.addAttribute("alt", prop).toString();
                        String path = getDistinguishingXPath(fullPath, null);
                        if (dataSource.getValueAtPath(path) != null) {
                            continue;
                        }
                        dataSource.putValueAtPath(fullPath, otherValue);
                        break;
                    }
                }
            }
        } else {
            throw new IllegalArgumentException("Illegal operand: " + conflict_resolution);
        }

        dataSource
                .getXpathComments()
                .setInitialComment(
                        CldrUtility.joinWithSeparation(
                                dataSource.getXpathComments().getInitialComment(),
                                XPathParts.NEWLINE,
                                other.dataSource.getXpathComments().getInitialComment()));
        dataSource
                .getXpathComments()
                .setFinalComment(
                        CldrUtility.joinWithSeparation(
                                dataSource.getXpathComments().getFinalComment(),
                                XPathParts.NEWLINE,
                                other.dataSource.getXpathComments().getFinalComment()));
        dataSource.getXpathComments().joinAll(other.dataSource.getXpathComments());
        return this;
    }

    /** */
    private String addReferencesIfNeeded(String newFullPath, String fullXPath) {
        if (fullXPath == null || fullXPath.indexOf("[@references=") < 0) {
            return newFullPath;
        }
        XPathParts parts = XPathParts.getFrozenInstance(fullXPath);
        String accummulatedReferences = null;
        for (int i = 0; i < parts.size(); ++i) {
            Map<String, String> attributes = parts.getAttributes(i);
            String references = attributes.get("references");
            if (references == null) {
                continue;
            }
            if (accummulatedReferences == null) {
                accummulatedReferences = references;
            } else {
                accummulatedReferences += ", " + references;
            }
        }
        if (accummulatedReferences == null) {
            return newFullPath;
        }
        XPathParts newParts = XPathParts.getFrozenInstance(newFullPath);
        Map<String, String> attributes = newParts.getAttributes(newParts.size() - 1);
        String references = attributes.get("references");
        if (references == null) references = accummulatedReferences;
        else references += ", " + accummulatedReferences;
        attributes.put("references", references);
        System.out.println(
                "Changing " + newFullPath + " plus " + fullXPath + " to " + newParts.toString());
        return newParts.toString();
    }

    /** Removes an element from a CLDRFile. */
    public CLDRFile remove(String xpath) {
        remove(xpath, false);
        return this;
    }

    /** Removes an element from a CLDRFile. */
    public CLDRFile remove(String xpath, boolean butComment) {
        if (locked) throw new UnsupportedOperationException("Attempt to modify locked object");
        if (butComment) {
            appendFinalComment(
                    dataSource.getFullPath(xpath) + "::<" + dataSource.getValueAtPath(xpath) + ">");
        }
        dataSource.removeValueAtPath(xpath);
        return this;
    }

    /** Removes all xpaths from a CLDRFile. */
    public CLDRFile removeAll(Set<String> xpaths, boolean butComment) {
        if (butComment) appendFinalComment("Illegal attributes removed:");
        for (Iterator<String> it = xpaths.iterator(); it.hasNext(); ) {
            remove(it.next(), butComment);
        }
        return this;
    }

    /** Code should explicitly include CODE_FALLBACK */
    public static final Pattern specialsToKeep =
            PatternCache.get(
                    "/("
                            + "measurementSystemName"
                            + "|codePattern"
                            + "|calendar\\[\\@type\\=\"[^\"]*\"\\]/(?!dateTimeFormats/appendItems)"
                            + // gregorian
                            "|numbers/symbols/(decimal/group)"
                            + "|timeZoneNames/(hourFormat|gmtFormat|regionFormat)"
                            + "|pattern"
                            + ")");

    public static final Pattern specialsToPushFromRoot =
            PatternCache.get(
                    "/("
                            + "calendar\\[\\@type\\=\"gregorian\"\\]/"
                            + "(?!fields)"
                            + "(?!dateTimeFormats/appendItems)"
                            + "(?!.*\\[@type=\"format\"].*\\[@type=\"narrow\"])"
                            + "(?!.*\\[@type=\"stand-alone\"].*\\[@type=\"(abbreviated|wide)\"])"
                            + "|numbers/symbols/(decimal/group)"
                            + "|timeZoneNames/(hourFormat|gmtFormat|regionFormat)"
                            + ")");

    private static final boolean MINIMIZE_ALT_PROPOSED = false;

    public interface RetentionTest {
        public enum Retention {
            RETAIN,
            REMOVE,
            RETAIN_IF_DIFFERENT
        }

        public Retention getRetention(String path);
    }

    /** Removes all items with same value */
    public CLDRFile removeDuplicates(
            CLDRFile other,
            boolean butComment,
            RetentionTest keepIfMatches,
            Collection<String> removedItems) {
        if (locked) throw new UnsupportedOperationException("Attempt to modify locked object");
        // Matcher specialPathMatcher = dontRemoveSpecials ? specialsToKeep.matcher("") : null;
        boolean first = true;
        if (removedItems == null) {
            removedItems = new ArrayList<>();
        } else {
            removedItems.clear();
        }
        Set<String> checked = new HashSet<>();
        for (Iterator<String> it = iterator();
                it.hasNext(); ) { // see what items we have that the other also has
            String curXpath = it.next();
            boolean logicDuplicate = true;

            if (!checked.contains(curXpath)) {
                // we compare logic Group and only remove when all are duplicate
                Set<String> logicGroups = LogicalGrouping.getPaths(this, curXpath);
                if (logicGroups != null) {
                    Iterator<String> iter = logicGroups.iterator();
                    while (iter.hasNext() && logicDuplicate) {
                        String xpath = iter.next();
                        switch (keepIfMatches.getRetention(xpath)) {
                            case RETAIN:
                                logicDuplicate = false;
                                continue;
                            case RETAIN_IF_DIFFERENT:
                                String currentValue = dataSource.getValueAtPath(xpath);
                                if (currentValue == null) {
                                    logicDuplicate = false;
                                    continue;
                                }
                                String otherXpath = xpath;
                                String otherValue = other.dataSource.getValueAtPath(otherXpath);
                                if (!currentValue.equals(otherValue)) {
                                    if (MINIMIZE_ALT_PROPOSED) {
                                        otherXpath = CLDRFile.getNondraftNonaltXPath(xpath);
                                        if (otherXpath.equals(xpath)) {
                                            logicDuplicate = false;
                                            continue;
                                        }
                                        otherValue = other.dataSource.getValueAtPath(otherXpath);
                                        if (!currentValue.equals(otherValue)) {
                                            logicDuplicate = false;
                                            continue;
                                        }
                                    } else {
                                        logicDuplicate = false;
                                        continue;
                                    }
                                }
                                String keepValue =
                                        XMLSource.getPathsAllowingDuplicates().get(xpath);
                                if (keepValue != null && keepValue.equals(currentValue)) {
                                    logicDuplicate = false;
                                    continue;
                                }
                                // we've now established that the values are the same
                                String currentFullXPath = dataSource.getFullPath(xpath);
                                String otherFullXPath = other.dataSource.getFullPath(otherXpath);
                                if (!equalsIgnoringDraft(currentFullXPath, otherFullXPath)) {
                                    logicDuplicate = false;
                                    continue;
                                }
                                if (DEBUG) {
                                    keepIfMatches.getRetention(xpath);
                                }
                                break;
                            case REMOVE:
                                if (DEBUG) {
                                    keepIfMatches.getRetention(xpath);
                                }
                                break;
                        }
                    }

                    if (first) {
                        first = false;
                        if (butComment) appendFinalComment("Duplicates removed:");
                    }
                }
                // we can't remove right away, since that disturbs the iterator.
                checked.addAll(logicGroups);
                if (logicDuplicate) {
                    removedItems.addAll(logicGroups);
                }
                // remove(xpath, butComment);
            }
        }
        // now remove them safely
        for (String xpath : removedItems) {
            remove(xpath, butComment);
        }
        return this;
    }

    /**
     * @return Returns the finalComment.
     */
    public String getFinalComment() {
        return dataSource.getXpathComments().getFinalComment();
    }

    /**
     * @return Returns the finalComment.
     */
    public String getInitialComment() {
        return dataSource.getXpathComments().getInitialComment();
    }

    /**
     * @return Returns the xpath_comments. Cloned for safety.
     */
    public XPathParts.Comments getXpath_comments() {
        return (XPathParts.Comments) dataSource.getXpathComments().clone();
    }

    /**
     * @return Returns the locale ID. In the case of a supplemental data file, it is
     *     SUPPLEMENTAL_NAME.
     */
    @Override
    public String getLocaleID() {
        return dataSource.getLocaleID();
    }

    /**
     * @return the Locale ID, as declared in the //ldml/identity element
     */
    public String getLocaleIDFromIdentity() {
        ULocale.Builder lb = new ULocale.Builder();
        for (Iterator<String> i = iterator("//ldml/identity/"); i.hasNext(); ) {
            XPathParts xpp = XPathParts.getFrozenInstance(i.next());
            String k = xpp.getElement(-1);
            String v = xpp.getAttributeValue(-1, "type");
            if (k.equals("language")) {
                lb = lb.setLanguage(v);
            } else if (k.equals("script")) {
                lb = lb.setScript(v);
            } else if (k.equals("territory")) {
                lb = lb.setRegion(v);
            } else if (k.equals("variant")) {
                lb = lb.setVariant(v);
            }
        }
        return lb.build().toString(); // TODO: CLDRLocale ?
    }

    /**
     * @see com.ibm.icu.util.Freezable#isFrozen()
     */
    @Override
    public synchronized boolean isFrozen() {
        return locked;
    }

    /**
     * @see com.ibm.icu.util.Freezable#freeze()
     */
    @Override
    public synchronized CLDRFile freeze() {
        locked = true;
        dataSource.freeze();
        return this;
    }

    public CLDRFile clearComments() {
        if (locked) throw new UnsupportedOperationException("Attempt to modify locked object");
        dataSource.setXpathComments(new XPathParts.Comments());
        return this;
    }

    /** Sets a final comment, replacing everything that was there. */
    public CLDRFile setFinalComment(String comment) {
        if (locked) throw new UnsupportedOperationException("Attempt to modify locked object");
        dataSource.getXpathComments().setFinalComment(comment);
        return this;
    }

    /** Adds a comment to the final list of comments. */
    public CLDRFile appendFinalComment(String comment) {
        if (locked) throw new UnsupportedOperationException("Attempt to modify locked object");
        dataSource
                .getXpathComments()
                .setFinalComment(
                        CldrUtility.joinWithSeparation(
                                dataSource.getXpathComments().getFinalComment(),
                                XPathParts.NEWLINE,
                                comment));
        return this;
    }

    /** Sets the initial comment, replacing everything that was there. */
    public CLDRFile setInitialComment(String comment) {
        if (locked) throw new UnsupportedOperationException("Attempt to modify locked object");
        dataSource.getXpathComments().setInitialComment(comment);
        return this;
    }

    // ========== STATIC UTILITIES ==========

    /**
     * Utility to restrict to files matching a given regular expression. The expression does not
     * contain ".xml". Note that supplementalData is always skipped, and root is always included.
     */
    public static Set<String> getMatchingXMLFiles(File sourceDirs[], Matcher m) {
        Set<String> s = new TreeSet<>();

        for (File dir : sourceDirs) {
            if (!dir.exists()) {
                throw new IllegalArgumentException("Directory doesn't exist:\t" + dir.getPath());
            }
            if (!dir.isDirectory()) {
                throw new IllegalArgumentException(
                        "Input isn't a file directory:\t" + dir.getPath());
            }
            File[] files = dir.listFiles();
            for (int i = 0; i < files.length; ++i) {
                String name = files[i].getName();
                if (!name.endsWith(".xml") || name.startsWith(".")) continue;
                // if (name.startsWith(SUPPLEMENTAL_NAME)) continue;
                String locale = name.substring(0, name.length() - 4); // drop .xml
                if (!m.reset(locale).matches()) continue;
                s.add(locale);
            }
        }
        return s;
    }

    @Override
    public Iterator<String> iterator() {
        return dataSource.iterator();
    }

    public synchronized Iterator<String> iterator(String prefix) {
        return dataSource.iterator(prefix);
    }

    public Iterator<String> iterator(Matcher pathFilter) {
        return dataSource.iterator(pathFilter);
    }

    public Iterator<String> iterator(String prefix, Comparator<String> comparator) {
        Iterator<String> it =
                (prefix == null || prefix.length() == 0)
                        ? dataSource.iterator()
                        : dataSource.iterator(prefix);
        if (comparator == null) return it;
        Set<String> orderedSet = new TreeSet<>(comparator);
        it.forEachRemaining(orderedSet::add);
        return orderedSet.iterator();
    }

    public Iterable<String> fullIterable() {
        return new FullIterable(this);
    }

    public static class FullIterable implements Iterable<String>, SimpleIterator<String> {
        private final CLDRFile file;
        private final Iterator<String> fileIterator;
        private Iterator<String> extraPaths;

        FullIterable(CLDRFile file) {
            this.file = file;
            this.fileIterator = file.iterator();
        }

        @Override
        public Iterator<String> iterator() {
            return With.toIterator(this);
        }

        @Override
        public String next() {
            if (fileIterator.hasNext()) {
                return fileIterator.next();
            }
            if (extraPaths == null) {
                extraPaths = file.getExtraPaths().iterator();
            }
            if (extraPaths.hasNext()) {
                return extraPaths.next();
            }
            return null;
        }
    }

    public static String getDistinguishingXPath(String xpath, String[] normalizedPath) {
        return DistinguishedXPath.getDistinguishingXPath(xpath, normalizedPath);
    }

    private static boolean equalsIgnoringDraft(String path1, String path2) {
        if (path1 == path2) {
            return true;
        }
        if (path1 == null || path2 == null) {
            return false;
        }
        // TODO: optimize
        if (path1.indexOf("[@draft=") < 0 && path2.indexOf("[@draft=") < 0) {
            return path1.equals(path2);
        }
        return getNondraftNonaltXPath(path1).equals(getNondraftNonaltXPath(path2));
    }

    /*
     * TODO: clarify the need for syncObject.
     * Formerly, an XPathParts object named "nondraftParts" was used for this purpose, but
     * there was no evident reason for it to be an XPathParts object rather than any other
     * kind of object.
     */
    private static Object syncObject = new Object();

    public static String getNondraftNonaltXPath(String xpath) {
        if (xpath.indexOf("draft=\"") < 0 && xpath.indexOf("alt=\"") < 0) {
            return xpath;
        }
        synchronized (syncObject) {
            XPathParts parts =
                    XPathParts.getFrozenInstance(xpath)
                            .cloneAsThawed(); // can't be frozen since we call removeAttributes
            String restore;
            HashSet<String> toRemove = new HashSet<>();
            for (int i = 0; i < parts.size(); ++i) {
                if (parts.getAttributeCount(i) == 0) {
                    continue;
                }
                Map<String, String> attributes = parts.getAttributes(i);
                toRemove.clear();
                restore = null;
                for (Iterator<String> it = attributes.keySet().iterator(); it.hasNext(); ) {
                    String attribute = it.next();
                    if (attribute.equals("draft")) {
                        toRemove.add(attribute);
                    } else if (attribute.equals("alt")) {
                        String value = attributes.get(attribute);
                        int proposedPos = value.indexOf("proposed");
                        if (proposedPos >= 0) {
                            toRemove.add(attribute);
                            if (proposedPos > 0) {
                                restore =
                                        value.substring(
                                                0, proposedPos - 1); // is of form xxx-proposedyyy
                            }
                        }
                    }
                }
                parts.removeAttributes(i, toRemove);
                if (restore != null) {
                    attributes.put("alt", restore);
                }
            }
            return parts.toString();
        }
    }

    /**
     * Determine if an attribute is a distinguishing attribute.
     *
     * @param elementName
     * @param attribute
     * @return
     */
    public static boolean isDistinguishing(DtdType type, String elementName, String attribute) {
        return DtdData.getInstance(type).isDistinguishing(elementName, attribute);
    }

    /** Utility to create a validating XML reader. */
    public static XMLReader createXMLReader(boolean validating) {
        String[] testList = {
            "org.apache.xerces.parsers.SAXParser",
            "org.apache.crimson.parser.XMLReaderImpl",
            "gnu.xml.aelfred2.XmlReader",
            "com.bluecast.xml.Piccolo",
            "oracle.xml.parser.v2.SAXParser",
            ""
        };
        XMLReader result = null;
        for (int i = 0; i < testList.length; ++i) {
            try {
                result =
                        (testList[i].length() != 0)
                                ? XMLReaderFactory.createXMLReader(testList[i])
                                : XMLReaderFactory.createXMLReader();
                result.setFeature("http://xml.org/sax/features/validation", validating);
                break;
            } catch (SAXException e1) {
            }
        }
        if (result == null)
            throw new NoClassDefFoundError(
                    "No SAX parser is available, or unable to set validation correctly");
        return result;
    }

    /**
     * Return a directory to supplemental data used by this CLDRFile. If the CLDRFile is not
     * normally disk-based, the returned directory may be temporary and not guaranteed to exist past
     * the lifetime of the CLDRFile. The directory should be considered read-only.
     */
    public File getSupplementalDirectory() {
        if (supplementalDirectory == null) {
            // ask CLDRConfig.
            supplementalDirectory =
                    CLDRConfig.getInstance().getSupplementalDataInfo().getDirectory();
        }
        return supplementalDirectory;
    }

    public CLDRFile setSupplementalDirectory(File supplementalDirectory) {
        this.supplementalDirectory = supplementalDirectory;
        return this;
    }

    /**
     * Convenience function to return a list of XML files in the Supplemental directory.
     *
     * @return all files ending in ".xml"
     * @see #getSupplementalDirectory()
     */
    public File[] getSupplementalXMLFiles() {
        return getSupplementalDirectory()
                .listFiles(
                        new FilenameFilter() {
                            @Override
                            public boolean accept(
                                    @SuppressWarnings("unused") File dir, String name) {
                                return name.endsWith(".xml");
                            }
                        });
    }

    /**
     * Convenience function to return a specific supplemental file
     *
     * @param filename the file to return
     * @return the file (may not exist)
     * @see #getSupplementalDirectory()
     */
    public File getSupplementalFile(String filename) {
        return new File(getSupplementalDirectory(), filename);
    }

    public static boolean isSupplementalName(String localeName) {
        return SUPPLEMENTAL_NAMES.contains(localeName);
    }

    // static String[] keys = {"calendar", "collation", "currency"};
    //
    // static String[] calendar_keys = {"buddhist", "chinese", "gregorian", "hebrew", "islamic",
    // "islamic-civil",
    // "japanese"};
    // static String[] collation_keys = {"phonebook", "traditional", "direct", "pinyin", "stroke",
    // "posix", "big5han",
    // "gb2312han"};

    /*    */
    /**
     * Value that contains a node. WARNING: this is not done yet, and may change. In particular, we
     * don't want to return a Node, since that is mutable, and makes caching unsafe!!
     */
    /*
     * static public class NodeValue extends Value {
     * private Node nodeValue;
     */
    /**
     * Creation. WARNING, may change.
     *
     * @param value
     * @param currentFullXPath
     */
    /*
     * public NodeValue(Node value, String currentFullXPath) {
     * super(currentFullXPath);
     * this.nodeValue = value;
     * }
     */
    /** boilerplate */

    /*
     * public boolean hasSameValue(Object other) {
     * if (super.hasSameValue(other)) return false;
     * return nodeValue.equals(((NodeValue)other).nodeValue);
     * }
     */
    /** boilerplate */
    /*
     * public String getStringValue() {
     * return nodeValue.toString();
     * }
     * (non-Javadoc)
     *
     * @see org.unicode.cldr.util.CLDRFile.Value#changePath(java.lang.String)
     *
     * public Value changePath(String string) {
     * return new NodeValue(nodeValue, string);
     * }
     * }
     */

    private static class MyDeclHandler implements AllHandler {
        private static UnicodeSet whitespace = new UnicodeSet("[:whitespace:]");
        private DraftStatus minimalDraftStatus;
        private static final boolean SHOW_START_END = false;
        private int commentStack;
        private boolean justPopped = false;
        private String lastChars = "";
        // private String currentXPath = "/";
        private String currentFullXPath = "/";
        private String comment = null;
        private Map<String, String> attributeOrder;
        private DtdData dtdData;
        private CLDRFile target;
        private String lastActiveLeafNode;
        private String lastLeafNode;
        private int isSupplemental = -1;
        private int[] orderedCounter =
                new int[30]; // just make deep enough to handle any CLDR file.
        private String[] orderedString =
                new String[30]; // just make deep enough to handle any CLDR file.
        private int level = 0;
        private int overrideCount = 0;
        private Locator documentLocator = null;

        MyDeclHandler(CLDRFile target, DraftStatus minimalDraftStatus) {
            this.target = target;
            this.minimalDraftStatus = minimalDraftStatus;
        }

        private String show(Attributes attributes) {
            if (attributes == null) return "null";
            String result = "";
            for (int i = 0; i < attributes.getLength(); ++i) {
                String attribute = attributes.getQName(i);
                String value = attributes.getValue(i);
                result += "[@" + attribute + "=\"" + value + "\"]"; // TODO quote the value??
            }
            return result;
        }

        private void push(String qName, Attributes attributes) {
            // SHOW_ALL &&
            Log.logln(LOG_PROGRESS, "push\t" + qName + "\t" + show(attributes));
            ++level;
            if (!qName.equals(orderedString[level])) {
                // orderedCounter[level] = 0;
                orderedString[level] = qName;
            }
            if (lastChars.length() != 0) {
                if (whitespace.containsAll(lastChars)) lastChars = "";
                else
                    throw new IllegalArgumentException(
                            "Must not have mixed content: "
                                    + qName
                                    + ", "
                                    + show(attributes)
                                    + ", Content: "
                                    + lastChars);
            }
            // currentXPath += "/" + qName;
            currentFullXPath += "/" + qName;
            // if (!isSupplemental) ldmlComparator.addElement(qName);
            if (dtdData.isOrdered(qName)) {
                currentFullXPath += orderingAttribute();
            }
            if (attributes.getLength() > 0) {
                attributeOrder.clear();
                for (int i = 0; i < attributes.getLength(); ++i) {
                    String attribute = attributes.getQName(i);
                    String value = attributes.getValue(i);

                    // if (!isSupplemental) ldmlComparator.addAttribute(attribute); // must do
                    // BEFORE put
                    // ldmlComparator.addValue(value);
                    // special fix to remove version
                    // <!ATTLIST version number CDATA #REQUIRED >
                    // <!ATTLIST version cldrVersion CDATA #FIXED "24" >
                    if (attribute.equals("cldrVersion") && (qName.equals("version"))) {
                        ((SimpleXMLSource) target.dataSource)
                                .setDtdVersionInfo(VersionInfo.getInstance(value));
                    } else {
                        putAndFixDeprecatedAttribute(qName, attribute, value);
                    }
                }
                for (Iterator<String> it = attributeOrder.keySet().iterator(); it.hasNext(); ) {
                    String attribute = it.next();
                    String value = attributeOrder.get(attribute);
                    String both =
                            "[@" + attribute + "=\"" + value + "\"]"; // TODO quote the value??
                    currentFullXPath += both;
                    // distinguishing = key, registry, alt, and type (except for the type attribute
                    // on the elements
                    // default and mapping).
                    // if (isDistinguishing(qName, attribute)) {
                    // currentXPath += both;
                    // }
                }
            }
            if (comment != null) {
                if (currentFullXPath.equals("//ldml")
                        || currentFullXPath.equals("//supplementalData")) {
                    target.setInitialComment(comment);
                } else {
                    target.addComment(
                            currentFullXPath, comment, XPathParts.Comments.CommentType.PREBLOCK);
                }
                comment = null;
            }
            justPopped = false;
            lastActiveLeafNode = null;
            Log.logln(LOG_PROGRESS, "currentFullXPath\t" + currentFullXPath);
        }

        private String orderingAttribute() {
            return "[@_q=\"" + (orderedCounter[level]++) + "\"]";
        }

        private void putAndFixDeprecatedAttribute(String element, String attribute, String value) {
            if (attribute.equals("draft")) {
                if (value.equals("true")) value = "approved";
                else if (value.equals("false")) value = "unconfirmed";
            } else if (attribute.equals("type")) {
                if (changedTypes.contains(element)
                        && isSupplemental < 1) { // measurementSystem for example did not
                    // change from 'type' to 'choice'.
                    attribute = "choice";
                }
            }
            // else if (element.equals("dateFormatItem")) {
            // if (attribute.equals("id")) {
            // String newValue = dateGenerator.getBaseSkeleton(value);
            // if (!fixedSkeletons.contains(newValue)) {
            // fixedSkeletons.add(newValue);
            // if (!value.equals(newValue)) {
            // System.out.println(value + " => " + newValue);
            // }
            // value = newValue;
            // }
            // }
            // }
            attributeOrder.put(attribute, value);
        }

        // private Set<String> fixedSkeletons = new HashSet();

        // private DateTimePatternGenerator dateGenerator =
        // DateTimePatternGenerator.getEmptyInstance();

        /** Types which changed from 'type' to 'choice', but not in supplemental data. */
        private static Set<String> changedTypes =
                new HashSet<>(
                        Arrays.asList(
                                new String[] {
                                    "abbreviationFallback",
                                    "default",
                                    "mapping",
                                    "measurementSystem",
                                    "preferenceOrdering"
                                }));

        Matcher draftMatcher = DRAFT_PATTERN.matcher("");

        /**
         * Adds a parsed XPath to the CLDRFile.
         *
         * @param fullXPath
         * @param value
         */
        private void addPath(String fullXPath, String value) {
            String former = target.getStringValue(fullXPath);
            if (former != null) {
                String formerPath = target.getFullXPath(fullXPath);
                if (!former.equals(value) || !fullXPath.equals(formerPath)) {
                    if (!fullXPath.startsWith("//ldml/identity/version")
                            && !fullXPath.startsWith("//ldml/identity/generation")) {
                        warnOnOverride(former, formerPath);
                    }
                }
            }
            value = trimWhitespaceSpecial(value);
            target.add(fullXPath, value)
                    .addSourceLocation(fullXPath, new XMLSource.SourceLocation(documentLocator));
        }

        private void pop(String qName) {
            Log.logln(LOG_PROGRESS, "pop\t" + qName);
            --level;

            if (lastChars.length() != 0 || justPopped == false) {
                boolean acceptItem = minimalDraftStatus == DraftStatus.unconfirmed;
                if (!acceptItem) {
                    if (draftMatcher.reset(currentFullXPath).find()) {
                        DraftStatus foundStatus = DraftStatus.valueOf(draftMatcher.group(1));
                        if (minimalDraftStatus.compareTo(foundStatus) <= 0) {
                            // what we found is greater than or equal to our status
                            acceptItem = true;
                        }
                    } else {
                        acceptItem =
                                true; // if not found, then the draft status is approved, so it is
                        // always ok
                    }
                }
                if (acceptItem) {
                    // Change any deprecated orientation attributes into values
                    // for backwards compatibility.
                    boolean skipAdd = false;
                    if (currentFullXPath.startsWith("//ldml/layout/orientation")) {
                        XPathParts parts = XPathParts.getFrozenInstance(currentFullXPath);
                        String value = parts.getAttributeValue(-1, "characters");
                        if (value != null) {
                            addPath("//ldml/layout/orientation/characterOrder", value);
                            skipAdd = true;
                        }
                        value = parts.getAttributeValue(-1, "lines");
                        if (value != null) {
                            addPath("//ldml/layout/orientation/lineOrder", value);
                            skipAdd = true;
                        }
                    }
                    if (!skipAdd) {
                        addPath(currentFullXPath, lastChars);
                    }
                    lastLeafNode = lastActiveLeafNode = currentFullXPath;
                }
                lastChars = "";
            } else {
                Log.logln(
                        LOG_PROGRESS && lastActiveLeafNode != null,
                        "pop: zeroing last leafNode: " + lastActiveLeafNode);
                lastActiveLeafNode = null;
                if (comment != null) {
                    target.addComment(
                            lastLeafNode, comment, XPathParts.Comments.CommentType.POSTBLOCK);
                    comment = null;
                }
            }
            // currentXPath = stripAfter(currentXPath, qName);
            currentFullXPath = stripAfter(currentFullXPath, qName);
            justPopped = true;
        }

        static Pattern WHITESPACE_WITH_LF = PatternCache.get("\\s*\\u000a\\s*");
        Matcher whitespaceWithLf = WHITESPACE_WITH_LF.matcher("");
        static final UnicodeSet CONTROLS = new UnicodeSet("[:cc:]");

        /**
         * Trim leading whitespace if there is a linefeed among them, then the same with trailing.
         *
         * @param source
         * @return
         */
        private String trimWhitespaceSpecial(String source) {
            if (DEBUG && CONTROLS.containsSome(source)) {
                System.out.println("*** " + source);
            }
            if (!source.contains("\n")) {
                return source;
            }
            source = whitespaceWithLf.reset(source).replaceAll("\n");
            return source;
        }

        private void warnOnOverride(String former, String formerPath) {
            String distinguishing = CLDRFile.getDistinguishingXPath(formerPath, null);
            System.out.println(
                    "\tERROR in "
                            + target.getLocaleID()
                            + ";\toverriding old value <"
                            + former
                            + "> at path "
                            + distinguishing
                            + "\twith\t<"
                            + lastChars
                            + ">"
                            + CldrUtility.LINE_SEPARATOR
                            + "\told fullpath: "
                            + formerPath
                            + CldrUtility.LINE_SEPARATOR
                            + "\tnew fullpath: "
                            + currentFullXPath);
            overrideCount += 1;
        }

        private static String stripAfter(String input, String qName) {
            int pos = findLastSlash(input);
            if (qName != null) {
                // assert input.substring(pos+1).startsWith(qName);
                if (!input.substring(pos + 1).startsWith(qName)) {
                    throw new IllegalArgumentException("Internal Error: should never get here.");
                }
            }
            return input.substring(0, pos);
        }

        private static int findLastSlash(String input) {
            int braceStack = 0;
            char inQuote = 0;
            for (int i = input.length() - 1; i >= 0; --i) {
                char ch = input.charAt(i);
                switch (ch) {
                    case '\'':
                    case '"':
                        if (inQuote == 0) {
                            inQuote = ch;
                        } else if (inQuote == ch) {
                            inQuote = 0; // come out of quote
                        }
                        break;
                    case '/':
                        if (inQuote == 0 && braceStack == 0) {
                            return i;
                        }
                        break;
                    case '[':
                        if (inQuote == 0) {
                            --braceStack;
                        }
                        break;
                    case ']':
                        if (inQuote == 0) {
                            ++braceStack;
                        }
                        break;
                }
            }
            return -1;
        }

        // SAX items we need to catch

        @Override
        public void startElement(String uri, String localName, String qName, Attributes attributes)
                throws SAXException {
            Log.logln(
                    LOG_PROGRESS || SHOW_START_END,
                    "startElement uri\t"
                            + uri
                            + "\tlocalName "
                            + localName
                            + "\tqName "
                            + qName
                            + "\tattributes "
                            + show(attributes));
            try {
                if (isSupplemental < 0) { // set by first element
                    attributeOrder =
                            new TreeMap<>(
                                    // HACK for ldmlIcu
                                    dtdData.dtdType == DtdType.ldml
                                            ? CLDRFile.getAttributeOrdering()
                                            : dtdData.getAttributeComparator());
                    isSupplemental = target.dtdType == DtdType.ldml ? 0 : 1;
                }
                push(qName, attributes);
            } catch (RuntimeException e) {
                e.printStackTrace();
                throw e;
            }
        }

        @Override
        public void endElement(String uri, String localName, String qName) throws SAXException {
            Log.logln(
                    LOG_PROGRESS || SHOW_START_END,
                    "endElement uri\t" + uri + "\tlocalName " + localName + "\tqName " + qName);
            try {
                pop(qName);
            } catch (RuntimeException e) {
                // e.printStackTrace();
                throw e;
            }
        }

        // static final char XML_LINESEPARATOR = (char) 0xA;
        // static final String XML_LINESEPARATOR_STRING = String.valueOf(XML_LINESEPARATOR);

        @Override
        public void characters(char[] ch, int start, int length) throws SAXException {
            try {
                String value = new String(ch, start, length);
                Log.logln(LOG_PROGRESS, "characters:\t" + value);
                // we will strip leading and trailing line separators in another place.
                // if (value.indexOf(XML_LINESEPARATOR) >= 0) {
                // value = value.replace(XML_LINESEPARATOR, '\u0020');
                // }
                lastChars += value;
                justPopped = false;
            } catch (RuntimeException e) {
                e.printStackTrace();
                throw e;
            }
        }

        @Override
        public void startDTD(String name, String publicId, String systemId) throws SAXException {
            Log.logln(
                    LOG_PROGRESS,
                    "startDTD name: "
                            + name
                            + ", publicId: "
                            + publicId
                            + ", systemId: "
                            + systemId);
            commentStack++;
            target.dtdType = DtdType.fromElement(name);
            target.dtdData = dtdData = DtdData.getInstance(target.dtdType);
        }

        @Override
        public void endDTD() throws SAXException {
            Log.logln(LOG_PROGRESS, "endDTD");
            commentStack--;
        }

        @Override
        public void comment(char[] ch, int start, int length) throws SAXException {
            final String string = new String(ch, start, length);
            Log.logln(LOG_PROGRESS, commentStack + " comment " + string);
            try {
                if (commentStack != 0) return;
                String comment0 = trimWhitespaceSpecial(string).trim();
                if (lastActiveLeafNode != null) {
                    target.addComment(
                            lastActiveLeafNode, comment0, XPathParts.Comments.CommentType.LINE);
                } else {
                    comment =
                            (comment == null ? comment0 : comment + XPathParts.NEWLINE + comment0);
                }
            } catch (RuntimeException e) {
                e.printStackTrace();
                throw e;
            }
        }

        @Override
        public void ignorableWhitespace(char[] ch, int start, int length) throws SAXException {
            if (LOG_PROGRESS)
                Log.logln(
                        LOG_PROGRESS,
                        "ignorableWhitespace length: "
                                + length
                                + ": "
                                + Utility.hex(new String(ch, start, length)));
            // if (lastActiveLeafNode != null) {
            for (int i = start; i < start + length; ++i) {
                if (ch[i] == '\n') {
                    Log.logln(
                            LOG_PROGRESS && lastActiveLeafNode != null,
                            "\\n: zeroing last leafNode: " + lastActiveLeafNode);
                    lastActiveLeafNode = null;
                    break;
                }
            }
            // }
        }

        @Override
        public void startDocument() throws SAXException {
            Log.logln(LOG_PROGRESS, "startDocument");
            commentStack = 0; // initialize
        }

        @Override
        public void endDocument() throws SAXException {
            Log.logln(LOG_PROGRESS, "endDocument");
            try {
                if (comment != null)
                    target.addComment(null, comment, XPathParts.Comments.CommentType.LINE);
            } catch (RuntimeException e) {
                e.printStackTrace();
                throw e;
            }
        }

        // ==== The following are just for debuggin =====

        @Override
        public void elementDecl(String name, String model) throws SAXException {
            Log.logln(LOG_PROGRESS, "Attribute\t" + name + "\t" + model);
        }

        @Override
        public void attributeDecl(
                String eName, String aName, String type, String mode, String value)
                throws SAXException {
            Log.logln(
                    LOG_PROGRESS,
                    "Attribute\t"
                            + eName
                            + "\t"
                            + aName
                            + "\t"
                            + type
                            + "\t"
                            + mode
                            + "\t"
                            + value);
        }

        @Override
        public void internalEntityDecl(String name, String value) throws SAXException {
            Log.logln(LOG_PROGRESS, "Internal Entity\t" + name + "\t" + value);
        }

        @Override
        public void externalEntityDecl(String name, String publicId, String systemId)
                throws SAXException {
            Log.logln(LOG_PROGRESS, "Internal Entity\t" + name + "\t" + publicId + "\t" + systemId);
        }

        @Override
        public void processingInstruction(String target, String data) throws SAXException {
            Log.logln(LOG_PROGRESS, "processingInstruction: " + target + ", " + data);
        }

        @Override
        public void skippedEntity(String name) throws SAXException {
            Log.logln(LOG_PROGRESS, "skippedEntity: " + name);
        }

        @Override
        public void setDocumentLocator(Locator locator) {
            Log.logln(LOG_PROGRESS, "setDocumentLocator Locator " + locator);
            documentLocator = locator;
        }

        @Override
        public void startPrefixMapping(String prefix, String uri) throws SAXException {
            Log.logln(LOG_PROGRESS, "startPrefixMapping prefix: " + prefix + ", uri: " + uri);
        }

        @Override
        public void endPrefixMapping(String prefix) throws SAXException {
            Log.logln(LOG_PROGRESS, "endPrefixMapping prefix: " + prefix);
        }

        @Override
        public void startEntity(String name) throws SAXException {
            Log.logln(LOG_PROGRESS, "startEntity name: " + name);
        }

        @Override
        public void endEntity(String name) throws SAXException {
            Log.logln(LOG_PROGRESS, "endEntity name: " + name);
        }

        @Override
        public void startCDATA() throws SAXException {
            Log.logln(LOG_PROGRESS, "startCDATA");
        }

        @Override
        public void endCDATA() throws SAXException {
            Log.logln(LOG_PROGRESS, "endCDATA");
        }

        /*
         * (non-Javadoc)
         *
         * @see org.xml.sax.ErrorHandler#error(org.xml.sax.SAXParseException)
         */
        @Override
        public void error(SAXParseException exception) throws SAXException {
            Log.logln(LOG_PROGRESS || true, "error: " + showSAX(exception));
            throw exception;
        }

        /*
         * (non-Javadoc)
         *
         * @see org.xml.sax.ErrorHandler#fatalError(org.xml.sax.SAXParseException)
         */
        @Override
        public void fatalError(SAXParseException exception) throws SAXException {
            Log.logln(LOG_PROGRESS, "fatalError: " + showSAX(exception));
            throw exception;
        }

        /*
         * (non-Javadoc)
         *
         * @see org.xml.sax.ErrorHandler#warning(org.xml.sax.SAXParseException)
         */
        @Override
        public void warning(SAXParseException exception) throws SAXException {
            Log.logln(LOG_PROGRESS, "warning: " + showSAX(exception));
            throw exception;
        }
    }

    /** Show a SAX exception in a readable form. */
    public static String showSAX(SAXParseException exception) {
        return exception.getMessage()
                + ";\t SystemID: "
                + exception.getSystemId()
                + ";\t PublicID: "
                + exception.getPublicId()
                + ";\t LineNumber: "
                + exception.getLineNumber()
                + ";\t ColumnNumber: "
                + exception.getColumnNumber();
    }

    /** Says whether the whole file is draft */
    public boolean isDraft() {
        String item = iterator().next();
        return item.startsWith("//ldml[@draft=\"unconfirmed\"]");
    }

    // public Collection keySet(Matcher regexMatcher, Collection output) {
    // if (output == null) output = new ArrayList(0);
    // for (Iterator it = keySet().iterator(); it.hasNext();) {
    // String path = (String)it.next();
    // if (regexMatcher.reset(path).matches()) {
    // output.add(path);
    // }
    // }
    // return output;
    // }

    // public Collection keySet(String regexPattern, Collection output) {
    // return keySet(PatternCache.get(regexPattern).matcher(""), output);
    // }

    /**
     * Gets the type of a given xpath, eg script, territory, ... TODO move to separate class
     *
     * @param xpath
     * @return
     */
    public static int getNameType(String xpath) {
        for (int i = 0; i < NameTable.length; ++i) {
            if (!xpath.startsWith(NameTable[i][0])) continue;
            if (xpath.indexOf(NameTable[i][1], NameTable[i][0].length()) >= 0) return i;
        }
        return -1;
    }

    /** Gets the display name for a type */
    public static String getNameTypeName(int index) {
        try {
            return getNameName(index);
        } catch (Exception e) {
            return "Illegal Type Name: " + index;
        }
    }

    public static final int NO_NAME = -1,
            LANGUAGE_NAME = 0,
            SCRIPT_NAME = 1,
            TERRITORY_NAME = 2,
            VARIANT_NAME = 3,
            CURRENCY_NAME = 4,
            CURRENCY_SYMBOL = 5,
            TZ_EXEMPLAR = 6,
            TZ_START = TZ_EXEMPLAR,
            TZ_GENERIC_LONG = 7,
            TZ_GENERIC_SHORT = 8,
            TZ_STANDARD_LONG = 9,
            TZ_STANDARD_SHORT = 10,
            TZ_DAYLIGHT_LONG = 11,
            TZ_DAYLIGHT_SHORT = 12,
            TZ_LIMIT = 13,
            KEY_NAME = 13,
            KEY_TYPE_NAME = 14,
            SUBDIVISION_NAME = 15,
            LIMIT_TYPES = 15;

    private static final String[][] NameTable = {
        {"//ldml/localeDisplayNames/languages/language[@type=\"", "\"]", "language"},
        {"//ldml/localeDisplayNames/scripts/script[@type=\"", "\"]", "script"},
        {"//ldml/localeDisplayNames/territories/territory[@type=\"", "\"]", "territory"},
        {"//ldml/localeDisplayNames/variants/variant[@type=\"", "\"]", "variant"},
        {"//ldml/numbers/currencies/currency[@type=\"", "\"]/displayName", "currency"},
        {"//ldml/numbers/currencies/currency[@type=\"", "\"]/symbol", "currency-symbol"},
        {"//ldml/dates/timeZoneNames/zone[@type=\"", "\"]/exemplarCity", "exemplar-city"},
        {"//ldml/dates/timeZoneNames/zone[@type=\"", "\"]/long/generic", "tz-generic-long"},
        {"//ldml/dates/timeZoneNames/zone[@type=\"", "\"]/short/generic", "tz-generic-short"},
        {"//ldml/dates/timeZoneNames/zone[@type=\"", "\"]/long/standard", "tz-standard-long"},
        {"//ldml/dates/timeZoneNames/zone[@type=\"", "\"]/short/standard", "tz-standard-short"},
        {"//ldml/dates/timeZoneNames/zone[@type=\"", "\"]/long/daylight", "tz-daylight-long"},
        {"//ldml/dates/timeZoneNames/zone[@type=\"", "\"]/short/daylight", "tz-daylight-short"},
        {"//ldml/localeDisplayNames/keys/key[@type=\"", "\"]", "key"},
        {"//ldml/localeDisplayNames/types/type[@key=\"", "\"][@type=\"", "\"]", "key|type"},
        {"//ldml/localeDisplayNames/subdivisions/subdivision[@type=\"", "\"]", "subdivision"},

        /**
         * <long> <generic>Newfoundland Time</generic> <standard>Newfoundland Standard
         * Time</standard> <daylight>Newfoundland Daylight Time</daylight> </long> - <short>
         * <generic>NT</generic> <standard>NST</standard> <daylight>NDT</daylight> </short>
         */
    };

    // private static final String[] TYPE_NAME = {"language", "script", "territory", "variant",
    // "currency",
    // "currency-symbol",
    // "tz-exemplar",
    // "tz-generic-long", "tz-generic-short"};

    public Iterator<String> getAvailableIterator(int type) {
        return iterator(NameTable[type][0]);
    }

    /**
     * @return the xpath used to access data of a given type
     */
    public static String getKey(int type, String code) {
        switch (type) {
            case VARIANT_NAME:
                code = code.toUpperCase(Locale.ROOT);
                break;
            case KEY_NAME:
                code = fixKeyName(code);
                break;
            case TZ_DAYLIGHT_LONG:
            case TZ_DAYLIGHT_SHORT:
            case TZ_EXEMPLAR:
            case TZ_GENERIC_LONG:
            case TZ_GENERIC_SHORT:
            case TZ_STANDARD_LONG:
            case TZ_STANDARD_SHORT:
                code = getLongTzid(code);
                break;
        }
        String[] nameTableRow = NameTable[type];
        if (code.contains("|")) {
            String[] codes = code.split("\\|");
            return nameTableRow[0]
                    + fixKeyName(codes[0])
                    + nameTableRow[1]
                    + codes[1]
                    + nameTableRow[2];
        } else {
            return nameTableRow[0] + code + nameTableRow[1];
        }
    }

    static final Relation<R2<String, String>, String> bcp47AliasMap =
            CLDRConfig.getInstance().getSupplementalDataInfo().getBcp47Aliases();

    public static String getLongTzid(String code) {
        if (!code.contains("/")) {
            Set<String> codes = bcp47AliasMap.get(Row.of("tz", code));
            if (codes != null && !codes.isEmpty()) {
                code = codes.iterator().next();
            }
        }
        return code;
    }

    static final ImmutableMap<String, String> FIX_KEY_NAME;

    static {
        Builder<String, String> temp = ImmutableMap.builder();
        for (String s :
                Arrays.asList(
                        "colAlternate",
                        "colBackwards",
                        "colCaseFirst",
                        "colCaseLevel",
                        "colNormalization",
                        "colNumeric",
                        "colReorder",
                        "colStrength")) {
            temp.put(s.toLowerCase(Locale.ROOT), s);
        }
        FIX_KEY_NAME = temp.build();
    }

    private static String fixKeyName(String code) {
        String result = FIX_KEY_NAME.get(code);
        return result == null ? code : result;
    }

    /**
     * @return the code used to access data of a given type from the path. Null if not found.
     */
    public static String getCode(String path) {
        int type = getNameType(path);
        if (type < 0) {
            throw new IllegalArgumentException("Illegal type in path: " + path);
        }
        String[] nameTableRow = NameTable[type];
        int start = nameTableRow[0].length();
        int end = path.indexOf(nameTableRow[1], start);
        return path.substring(start, end);
    }

    /**
     * @param type a string such as "language", "script", "territory", "region", ...
     * @return the corresponding integer
     */
    public static int typeNameToCode(String type) {
        if (type.equalsIgnoreCase("region")) {
            type = "territory";
        }
        for (int i = 0; i < LIMIT_TYPES; ++i) {
            if (type.equalsIgnoreCase(getNameName(i))) {
                return i;
            }
        }
        return -1;
    }

    /** For use in getting short names. */
    public static final Transform<String, String> SHORT_ALTS =
            new Transform<>() {
                @Override
                public String transform(@SuppressWarnings("unused") String source) {
                    return "short";
                }
            };

    /** Returns the name of a type. */
    public static String getNameName(int choice) {
        String[] nameTableRow = NameTable[choice];
        return nameTableRow[nameTableRow.length - 1];
    }

    /**
     * Get standard ordering for elements.
     *
     * @return ordered collection with items.
     * @deprecated
     */
    @Deprecated
    public static List<String> getElementOrder() {
        return Collections.emptyList(); // elementOrdering.getOrder(); // already unmodifiable
    }

    /**
     * Get standard ordering for attributes.
     *
     * @return ordered collection with items.
     */
    public static List<String> getAttributeOrder() {
        return getAttributeOrdering().getOrder(); // already unmodifiable
    }

    public static boolean isOrdered(String element, DtdType type) {
        return DtdData.getInstance(type).isOrdered(element);
    }

    private static Comparator<String> ldmlComparator =
            DtdData.getInstance(DtdType.ldmlICU).getDtdComparator(null);

    private static final Map<String, Map<String, String>> defaultSuppressionMap;

    static {
        String[][] data = {
            {"ldml", "version", GEN_VERSION},
            {"version", "cldrVersion", "*"},
            {"orientation", "characters", "left-to-right"},
            {"orientation", "lines", "top-to-bottom"},
            {"weekendStart", "time", "00:00"},
            {"weekendEnd", "time", "24:00"},
            {"dateFormat", "type", "standard"},
            {"timeFormat", "type", "standard"},
            {"dateTimeFormat", "type", "standard"},
            {"decimalFormat", "type", "standard"},
            {"scientificFormat", "type", "standard"},
            {"percentFormat", "type", "standard"},
            {"pattern", "type", "standard"},
            {"currency", "type", "standard"},
            {"transform", "visibility", "external"},
            {"*", "_q", "*"},
        };
        Map<String, Map<String, String>> tempmain = asMap(data, true);
        defaultSuppressionMap = Collections.unmodifiableMap(tempmain);
    }

    public static Map<String, Map<String, String>> getDefaultSuppressionMap() {
        return defaultSuppressionMap;
    }

    @SuppressWarnings({"rawtypes", "unchecked"})
    private static Map asMap(String[][] data, boolean tree) {
        Map tempmain = tree ? (Map) new TreeMap() : new HashMap();
        int len = data[0].length; // must be same for all elements
        for (int i = 0; i < data.length; ++i) {
            Map temp = tempmain;
            if (len != data[i].length) {
                throw new IllegalArgumentException("Must be square array: fails row " + i);
            }
            for (int j = 0; j < len - 2; ++j) {
                Map newTemp = (Map) temp.get(data[i][j]);
                if (newTemp == null) {
                    temp.put(data[i][j], newTemp = tree ? (Map) new TreeMap() : new HashMap());
                }
                temp = newTemp;
            }
            temp.put(data[i][len - 2], data[i][len - 1]);
        }
        return tempmain;
    }

    /** Removes a comment. */
    public CLDRFile removeComment(String string) {
        if (locked) throw new UnsupportedOperationException("Attempt to modify locked object");
        dataSource.getXpathComments().removeComment(string);
        return this;
    }

    /**
     * @param draftStatus TODO
     */
    public CLDRFile makeDraft(DraftStatus draftStatus) {
        if (locked) throw new UnsupportedOperationException("Attempt to modify locked object");
        for (Iterator<String> it = dataSource.iterator(); it.hasNext(); ) {
            String path = it.next();
            XPathParts parts =
                    XPathParts.getFrozenInstance(dataSource.getFullPath(path))
                            .cloneAsThawed(); // not frozen, for addAttribute
            parts.addAttribute("draft", draftStatus.toString());
            dataSource.putValueAtPath(parts.toString(), dataSource.getValueAtPath(path));
        }
        return this;
    }

    public UnicodeSet getExemplarSet(String type, WinningChoice winningChoice) {
        return getExemplarSet(type, winningChoice, UnicodeSet.CASE);
    }

    public UnicodeSet getExemplarSet(ExemplarType type, WinningChoice winningChoice) {
        return getExemplarSet(type, winningChoice, UnicodeSet.CASE);
    }

    static final UnicodeSet HACK_CASE_CLOSURE_SET =
            new UnicodeSet(
                            "[ſẛffẞ{i̇}\u1F71\u1F73\u1F75\u1F77\u1F79\u1F7B\u1F7D\u1FBB\u1FBE\u1FC9\u1FCB\u1FD3\u1FDB\u1FE3\u1FEB\u1FF9\u1FFB\u2126\u212A\u212B]")
                    .freeze();

    public enum ExemplarType {
        main,
        auxiliary,
        index,
        punctuation,
        numbers;

        public static ExemplarType fromString(String type) {
            return type.isEmpty() ? main : valueOf(type);
        }
    }

    public UnicodeSet getExemplarSet(String type, WinningChoice winningChoice, int option) {
        return getExemplarSet(ExemplarType.fromString(type), winningChoice, option);
    }

    public UnicodeSet getExemplarSet(ExemplarType type, WinningChoice winningChoice, int option) {
        UnicodeSet result = getRawExemplarSet(type, winningChoice);
        if (result.isEmpty()) {
            return result.cloneAsThawed();
        }
        UnicodeSet toNuke = new UnicodeSet(HACK_CASE_CLOSURE_SET).removeAll(result);
        result.closeOver(UnicodeSet.CASE);
        result.removeAll(toNuke);
        result.remove(0x20);
        return result;
    }

    public UnicodeSet getRawExemplarSet(ExemplarType type, WinningChoice winningChoice) {
        String path = getExemplarPath(type);
        if (winningChoice == WinningChoice.WINNING) {
            path = getWinningPath(path);
        }
        String v = getStringValueWithBailey(path);
        if (v == null) {
            return UnicodeSet.EMPTY;
        }
        UnicodeSet result = SimpleUnicodeSetFormatter.parseLenient(v);
        return result;
    }

    public static String getExemplarPath(ExemplarType type) {
        return "//ldml/characters/exemplarCharacters"
                + (type == ExemplarType.main ? "" : "[@type=\"" + type + "\"]");
    }

    public enum NumberingSystem {
        latin(null),
        defaultSystem("//ldml/numbers/defaultNumberingSystem"),
        nativeSystem("//ldml/numbers/otherNumberingSystems/native"),
        traditional("//ldml/numbers/otherNumberingSystems/traditional"),
        finance("//ldml/numbers/otherNumberingSystems/finance");
        public final String path;

        private NumberingSystem(String path) {
            this.path = path;
        }
    }

    public UnicodeSet getExemplarsNumeric(NumberingSystem system) {
        String numberingSystem = system.path == null ? "latn" : getStringValue(system.path);
        if (numberingSystem == null) {
            return UnicodeSet.EMPTY;
        }
        return getExemplarsNumeric(numberingSystem);
    }

    public UnicodeSet getExemplarsNumeric(String numberingSystem) {
        UnicodeSet result = new UnicodeSet();
        SupplementalDataInfo sdi = CLDRConfig.getInstance().getSupplementalDataInfo();
        String[] symbolPaths = {
            "decimal", "group", "percentSign", "perMille", "plusSign", "minusSign",
            // "infinity"
        };

        String digits = sdi.getDigits(numberingSystem);
        if (digits != null) { // TODO, get other characters, see ticket:8316
            result.addAll(digits);
        }
        for (String path : symbolPaths) {
            String fullPath =
                    "//ldml/numbers/symbols[@numberSystem=\"" + numberingSystem + "\"]/" + path;
            String value = getStringValue(fullPath);
            if (value != null) {
                result.add(value);
            }
        }

        return result;
    }

    public String getCurrentMetazone(String zone) {
        for (Iterator<String> it2 = iterator(); it2.hasNext(); ) {
            String xpath = it2.next();
            if (xpath.startsWith(
                    "//ldml/dates/timeZoneNames/zone[@type=\"" + zone + "\"]/usesMetazone")) {
                XPathParts parts = XPathParts.getFrozenInstance(xpath);
                if (!parts.containsAttribute("to")) {
                    return parts.getAttributeValue(4, "mzone");
                }
            }
        }
        return null;
    }

    public boolean isResolved() {
        return dataSource.isResolving();
    }

    // WARNING: this must go AFTER attributeOrdering is set; otherwise it uses a null comparator!!
    /*
     * TODO: clarify the warning. There is nothing named "attributeOrdering" in this file.
     * This member distinguishedXPath is accessed only by the function getNonDistinguishingAttributes.
     */
    private static final DistinguishedXPath distinguishedXPath = new DistinguishedXPath();

    public static final String distinguishedXPathStats() {
        return DistinguishedXPath.stats();
    }

    private static class DistinguishedXPath {

        public static final String stats() {
            return "distinguishingMap:"
                    + distinguishingMap.size()
                    + " "
                    + "normalizedPathMap:"
                    + normalizedPathMap.size();
        }

        private static Map<String, String> distinguishingMap = new ConcurrentHashMap<>();
        private static Map<String, String> normalizedPathMap = new ConcurrentHashMap<>();

        static {
            distinguishingMap.put("", ""); // seed this to make the code simpler
        }

        public static String getDistinguishingXPath(String xpath, String[] normalizedPath) {
            // For example, this removes [@xml:space="preserve"] from a path with element
            // foreignSpaceReplacement.
            //     synchronized (distinguishingMap) {
            String result = distinguishingMap.get(xpath);
            if (result == null) {
                XPathParts distinguishingParts =
                        XPathParts.getFrozenInstance(xpath)
                                .cloneAsThawed(); // not frozen, for removeAttributes

                DtdType type = distinguishingParts.getDtdData().dtdType;
                Set<String> toRemove = new HashSet<>();

                // first clean up draft and alt
                String draft = null;
                String alt = null;
                String references = "";
                // note: we only need to clean up items that are NOT on the last element,
                // so we go up to size() - 1.

                // note: each successive item overrides the previous one. That's intended

                for (int i = 0; i < distinguishingParts.size() - 1; ++i) {
                    if (distinguishingParts.getAttributeCount(i) == 0) {
                        continue;
                    }
                    toRemove.clear();
                    Map<String, String> attributes = distinguishingParts.getAttributes(i);
                    for (String attribute : attributes.keySet()) {
                        if (attribute.equals("draft")) {
                            draft = attributes.get(attribute);
                            toRemove.add(attribute);
                        } else if (attribute.equals("alt")) {
                            alt = attributes.get(attribute);
                            toRemove.add(attribute);
                        } else if (attribute.equals("references")) {
                            if (references.length() != 0) references += " ";
                            references += attributes.get("references");
                            toRemove.add(attribute);
                        }
                    }
                    distinguishingParts.removeAttributes(i, toRemove);
                }
                if (draft != null || alt != null || references.length() != 0) {
                    // get the last element that is not ordered.
                    int placementIndex = distinguishingParts.size() - 1;
                    while (true) {
                        String element = distinguishingParts.getElement(placementIndex);
                        if (!DtdData.getInstance(type).isOrdered(element)) break;
                        --placementIndex;
                    }
                    if (draft != null) {
                        distinguishingParts.putAttributeValue(placementIndex, "draft", draft);
                    }
                    if (alt != null) {
                        distinguishingParts.putAttributeValue(placementIndex, "alt", alt);
                    }
                    if (references.length() != 0) {
                        distinguishingParts.putAttributeValue(
                                placementIndex, "references", references);
                    }
                    String newXPath = distinguishingParts.toString();
                    if (!newXPath.equals(xpath)) {
                        normalizedPathMap.put(xpath, newXPath); // store differences
                    }
                }

                // now remove non-distinguishing attributes (if non-inheriting)
                for (int i = 0; i < distinguishingParts.size(); ++i) {
                    if (distinguishingParts.getAttributeCount(i) == 0) {
                        continue;
                    }
                    String element = distinguishingParts.getElement(i);
                    toRemove.clear();
                    for (String attribute : distinguishingParts.getAttributeKeys(i)) {
                        if (!isDistinguishing(type, element, attribute)) {
                            toRemove.add(attribute);
                        }
                    }
                    distinguishingParts.removeAttributes(i, toRemove);
                }

                result = distinguishingParts.toString();
                if (result.equals(xpath)) { // don't save the copy if we don't have to.
                    result = xpath;
                }
                distinguishingMap.put(xpath, result);
            }
            if (normalizedPath != null) {
                normalizedPath[0] = normalizedPathMap.get(xpath);
                if (normalizedPath[0] == null) {
                    normalizedPath[0] = xpath;
                }
            }
            return result;
        }

        public Map<String, String> getNonDistinguishingAttributes(
                String fullPath, Map<String, String> result, Set<String> skipList) {
            if (result == null) {
                result = new LinkedHashMap<>();
            } else {
                result.clear();
            }
            XPathParts distinguishingParts = XPathParts.getFrozenInstance(fullPath);
            DtdType type = distinguishingParts.getDtdData().dtdType;
            for (int i = 0; i < distinguishingParts.size(); ++i) {
                String element = distinguishingParts.getElement(i);
                Map<String, String> attributes = distinguishingParts.getAttributes(i);
                for (Iterator<String> it = attributes.keySet().iterator(); it.hasNext(); ) {
                    String attribute = it.next();
                    if (!isDistinguishing(type, element, attribute)
                            && !skipList.contains(attribute)) {
                        result.put(attribute, attributes.get(attribute));
                    }
                }
            }
            return result;
        }
    }

    /** Fillin value for {@link CLDRFile#getSourceLocaleID(String, Status)} */
    public static class Status {
        /**
         * XPath where originally found. May be {@link GlossonymConstructor#PSEUDO_PATH} if the
         * value was constructed.
         *
         * @see GlossonymnConstructor
         */
        public String pathWhereFound;

        @Override
        public String toString() {
            return pathWhereFound;
        }
    }

    public static boolean isLOG_PROGRESS() {
        return LOG_PROGRESS;
    }

    public static void setLOG_PROGRESS(boolean log_progress) {
        LOG_PROGRESS = log_progress;
    }

    public boolean isEmpty() {
        return !dataSource.iterator().hasNext();
    }

    public Map<String, String> getNonDistinguishingAttributes(
            String fullPath, Map<String, String> result, Set<String> skipList) {
        return distinguishedXPath.getNonDistinguishingAttributes(fullPath, result, skipList);
    }

    public String getDtdVersion() {
        return dataSource.getDtdVersionInfo().toString();
    }

    public VersionInfo getDtdVersionInfo() {
        VersionInfo result = dataSource.getDtdVersionInfo();
        if (result != null || isEmpty()) {
            return result;
        }
        // for old files, pick the version from the @version attribute
        String path = dataSource.iterator().next();
        String full = getFullXPath(path);
        XPathParts parts = XPathParts.getFrozenInstance(full);
        String versionString = parts.findFirstAttributeValue("version");
        return versionString == null ? null : VersionInfo.getInstance(versionString);
    }

    private boolean contains(Map<String, String> a, Map<String, String> b) {
        for (Iterator<String> it = b.keySet().iterator(); it.hasNext(); ) {
            String key = it.next();
            String otherValue = a.get(key);
            if (otherValue == null) {
                return false;
            }
            String value = b.get(key);
            if (!otherValue.equals(value)) {
                return false;
            }
        }
        return true;
    }

    public String getFullXPath(String path, boolean ignoreOtherLeafAttributes) {
        String result = getFullXPath(path);
        if (result != null) return result;
        XPathParts parts = XPathParts.getFrozenInstance(path);
        Map<String, String> lastAttributes = parts.getAttributes(parts.size() - 1);
        String base =
                parts.toString(parts.size() - 1)
                        + "/"
                        + parts.getElement(parts.size() - 1); // trim final element
        for (Iterator<String> it = iterator(base); it.hasNext(); ) {
            String otherPath = it.next();
            XPathParts other = XPathParts.getFrozenInstance(otherPath);
            if (other.size() != parts.size()) {
                continue;
            }
            Map<String, String> lastOtherAttributes = other.getAttributes(other.size() - 1);
            if (!contains(lastOtherAttributes, lastAttributes)) {
                continue;
            }
            if (result == null) {
                result = getFullXPath(otherPath);
            } else {
                throw new IllegalArgumentException("Multiple values for path: " + path);
            }
        }
        return result;
    }

    /**
     * Return true if this item is the "winner" in the survey tool
     *
     * @param path
     * @return
     */
    public boolean isWinningPath(String path) {
        return dataSource.isWinningPath(path);
    }

    /**
     * Returns the "winning" path, for use in the survey tool tests, out of all those paths that
     * only differ by having "alt proposed". The exact meaning may be tweaked over time, but the
     * user's choice (vote) has precedence, then any undisputed choice, then the "best" choice of
     * the remainders. A value is always returned if there is a valid path, and the returned value
     * is always a valid path <i>in the resolved file</i>; that is, it may be valid in the parent,
     * or valid because of aliasing.
     *
     * @param path
     * @return path, perhaps with an alt proposed added.
     */
    public String getWinningPath(String path) {
        return dataSource.getWinningPath(path);
    }

    /**
     * Shortcut for getting the string value for the winning path
     *
     * @param path
     * @return
     */
    public String getWinningValue(String path) {
        final String winningPath = getWinningPath(path);
        return winningPath == null ? null : getStringValue(winningPath);
    }

    /**
     * Shortcut for getting the string value for the winning path. If the winning value is an {@link
     * CldrUtility#INHERITANCE_MARKER} (used in survey tool), then the Bailey value is returned.
     *
     * @param path
     * @return the winning value
     */
    public String getWinningValueWithBailey(String path) {
        final String winningPath = getWinningPath(path);
        return winningPath == null ? null : getStringValueWithBailey(winningPath);
    }

    /**
     * Shortcut for getting the string value for a path. If the string value is an {@link
     * CldrUtility#INHERITANCE_MARKER} (used in survey tool), then the Bailey value is returned.
     *
     * @param path
     * @return the string value
     */
    public String getStringValueWithBailey(String path) {
        return getStringValueWithBailey(path, null, null);
    }

    /**
     * Shortcut for getting the string value for a path. If the string value is an {@link
     * CldrUtility#INHERITANCE_MARKER} (used in survey tool), then the Bailey value is returned.
     *
     * @param path the given xpath
     * @param pathWhereFound if not null, to be filled in with the path where the value is actually
     *     found. May be {@link GlossonymConstructor#PSEUDO_PATH} if constructed.
     * @param localeWhereFound if not null, to be filled in with the locale where the value is
     *     actually found. May be {@link XMLSource#CODE_FALLBACK_ID} if not in root.
     * @return the string value
     */
    public String getStringValueWithBailey(
            String path, Output<String> pathWhereFound, Output<String> localeWhereFound) {
        String value = getStringValue(path);
        if (CldrUtility.INHERITANCE_MARKER.equals(value)) {
            value = getBaileyValue(path, pathWhereFound, localeWhereFound);
        } else if (localeWhereFound != null || pathWhereFound != null) {
            final Status status = new Status();
            final String localeWhereFound2 = getSourceLocaleID(path, status);
            if (localeWhereFound != null) {
                localeWhereFound.value = localeWhereFound2;
            }
            if (pathWhereFound != null) {
                pathWhereFound.value = status.pathWhereFound;
            }
        }
        return value;
    }

    /**
     * Return the distinguished paths that have the specified value. The pathPrefix and pathMatcher
     * can be used to restrict the returned paths to those matching. The pathMatcher can be null
     * (equals .*).
     *
     * @param valueToMatch
     * @param pathPrefix
     * @return
     */
    public Set<String> getPathsWithValue(
            String valueToMatch, String pathPrefix, Matcher pathMatcher, Set<String> result) {
        if (result == null) {
            result = new HashSet<>();
        }
        dataSource.getPathsWithValue(valueToMatch, pathPrefix, result);
        if (pathMatcher == null) {
            return result;
        }
        for (Iterator<String> it = result.iterator(); it.hasNext(); ) {
            String path = it.next();
            if (!pathMatcher.reset(path).matches()) {
                it.remove();
            }
        }
        return result;
    }

    /**
     * Return the distinguished paths that match the pathPrefix and pathMatcher The pathMatcher can
     * be null (equals .*).
     */
    public Set<String> getPaths(String pathPrefix, Matcher pathMatcher, Set<String> result) {
        if (result == null) {
            result = new HashSet<>();
        }
        for (Iterator<String> it = dataSource.iterator(pathPrefix); it.hasNext(); ) {
            String path = it.next();
            if (pathMatcher != null && !pathMatcher.reset(path).matches()) {
                continue;
            }
            result.add(path);
        }
        return result;
    }

    public enum WinningChoice {
        NORMAL,
        WINNING
    }

    /**
     * Used in TestUser to get the "winning" path. Simple implementation just for testing.
     *
     * @author markdavis
     */
    static class WinningComparator implements Comparator<String> {
        String user;

        public WinningComparator(String user) {
            this.user = user;
        }

        /**
         * if it contains the user, sort first. Otherwise use normal string sorting. A better
         * implementation would look at the number of votes next, and whither there was an approved
         * or provisional path.
         */
        @Override
        public int compare(String o1, String o2) {
            if (o1.contains(user)) {
                if (!o2.contains(user)) {
                    return -1; // if it contains user
                }
            } else if (o2.contains(user)) {
                return 1; // if it contains user
            }
            return o1.compareTo(o2);
        }
    }

    /**
     * This is a test class used to simulate what the survey tool would do.
     *
     * @author markdavis
     */
    public static class TestUser extends CLDRFile {

        Map<String, String> userOverrides = new HashMap<>();

        public TestUser(CLDRFile baseFile, String user, boolean resolved) {
            super(resolved ? baseFile.dataSource : baseFile.dataSource.getUnresolving());
            if (!baseFile.isResolved()) {
                throw new IllegalArgumentException("baseFile must be resolved");
            }
            Relation<String, String> pathMap =
                    Relation.of(
                            new HashMap<String, Set<String>>(),
                            TreeSet.class,
                            new WinningComparator(user));
            for (String path : baseFile) {
                String newPath = getNondraftNonaltXPath(path);
                pathMap.put(newPath, path);
            }
            // now reduce the storage by just getting the winning ones
            // so map everything but the first path to the first path
            for (String path : pathMap.keySet()) {
                String winner = null;
                for (String rowPath : pathMap.getAll(path)) {
                    if (winner == null) {
                        winner = rowPath;
                        continue;
                    }
                    userOverrides.put(rowPath, winner);
                }
            }
        }

        @Override
        public String getWinningPath(String path) {
            String trial = userOverrides.get(path);
            if (trial != null) {
                return trial;
            }
            return path;
        }
    }

    /**
     * Returns the extra paths, skipping those that are already represented in the locale.
     *
     * @return
     */
    public Collection<String> getExtraPaths() {
        Set<String> toAddTo = new HashSet<>();
        toAddTo.addAll(getRawExtraPaths());
        for (String path : this) {
            toAddTo.remove(path);
        }
        return toAddTo;
    }

    /**
     * Returns the extra paths, skipping those that are already represented in the locale.
     *
     * @return
     */
    public Collection<String> getExtraPaths(String prefix, Collection<String> toAddTo) {
        for (String item : getRawExtraPaths()) {
            if (item.startsWith(prefix)
                    && dataSource.getValueAtPath(item) == null) { // don't use getStringValue, since
                // it recurses.
                toAddTo.add(item);
            }
        }
        return toAddTo;
    }

    // extraPaths contains the raw extra paths.
    // It requires filtering in those cases where we don't want duplicate paths.
    /**
     * Returns the raw extra paths, irrespective of what paths are already represented in the
     * locale.
     *
     * @return
     */
    public Set<String> getRawExtraPaths() {
        if (extraPaths == null) {
            extraPaths =
                    ImmutableSet.<String>builder()
                            .addAll(getRawExtraPathsPrivate())
                            .addAll(CONST_EXTRA_PATHS)
                            .build();
            if (DEBUG) {
                System.out.println(getLocaleID() + "\textras: " + extraPaths.size());
            }
        }
        return extraPaths;
    }

    /**
     * Add (possibly over four thousand) extra paths to the given collection. These are paths that
     * typically don't have a reasonable fallback value that could be added to root. Some of them
     * are common to all locales, and some of them are specific to the given locale, based on
     * features like the plural rules for the locale.
     *
     * <p>The ones that are constant for all locales should go into CONST_EXTRA_PATHS.
     *
     * @return toAddTo (the collection)
     *     <p>Called only by getRawExtraPaths.
     *     <p>"Raw" refers to the fact that some of the paths may duplicate paths that are already
     *     in this CLDRFile (in the xml and/or votes), in which case they will later get filtered by
     *     getExtraPaths (removed from toAddTo) rather than re-added.
     *     <p>NOTE: values may be null for some "extra" paths in locales for which no explicit
     *     values have been submitted. Both unit tests and Survey Tool client code generate errors
     *     or warnings for null value, but allow null value for certain exceptional extra paths. See
     *     the functions named extraPathAllowsNullValue in TestPaths.java and in the JavaScript
     *     client code. Make sure that updates here are reflected there and vice versa.
     *     <p>Reference: https://unicode-org.atlassian.net/browse/CLDR-11238
     */
    private List<String> getRawExtraPathsPrivate() {
        Set<String> toAddTo = new HashSet<>();
        SupplementalDataInfo supplementalData = CLDRConfig.getInstance().getSupplementalDataInfo();
        // units
        PluralInfo plurals = supplementalData.getPlurals(PluralType.cardinal, getLocaleID());
        if (plurals == null && DEBUG) {
            System.err.println(
                    "No "
                            + PluralType.cardinal
                            + "  plurals for "
                            + getLocaleID()
                            + " in "
                            + supplementalData.getDirectory().getAbsolutePath());
        }
        Set<Count> pluralCounts = Collections.emptySet();
        if (plurals != null) {
            pluralCounts = plurals.getAdjustedCounts();
            Set<Count> pluralCountsRaw = plurals.getCounts();
            if (pluralCountsRaw.size() != 1) {
                // we get all the root paths with count
                addPluralCounts(toAddTo, pluralCounts, pluralCountsRaw, this);
            }
        }
        // dayPeriods
        String locale = getLocaleID();
        DayPeriodInfo dayPeriods =
                supplementalData.getDayPeriods(DayPeriodInfo.Type.format, locale);
        if (dayPeriods != null) {
            LinkedHashSet<DayPeriod> items = new LinkedHashSet<>(dayPeriods.getPeriods());
            items.add(DayPeriod.am);
            items.add(DayPeriod.pm);
            for (String context : new String[] {"format", "stand-alone"}) {
                for (String width : new String[] {"narrow", "abbreviated", "wide"}) {
                    for (DayPeriod dayPeriod : items) {
                        // ldml/dates/calendars/calendar[@type="gregorian"]/dayPeriods/dayPeriodContext[@type="format"]/dayPeriodWidth[@type="wide"]/dayPeriod[@type="am"]
                        toAddTo.add(
                                "//ldml/dates/calendars/calendar[@type=\"gregorian\"]/dayPeriods/"
                                        + "dayPeriodContext[@type=\""
                                        + context
                                        + "\"]/dayPeriodWidth[@type=\""
                                        + width
                                        + "\"]/dayPeriod[@type=\""
                                        + dayPeriod
                                        + "\"]");
                    }
                }
            }
        }

        // metazones
        Set<String> zones = supplementalData.getAllMetazones();

        for (String zone : zones) {
            final boolean metazoneUsesDST = CheckMetazones.metazoneUsesDST(zone);
            for (String width : new String[] {"long", "short"}) {
                for (String type : new String[] {"generic", "standard", "daylight"}) {
                    if (metazoneUsesDST || type.equals("standard")) {
                        // Only add /standard for non-DST metazones
                        final String path =
                                "//ldml/dates/timeZoneNames/metazone[@type=\""
                                        + zone
                                        + "\"]/"
                                        + width
                                        + "/"
                                        + type;
                        toAddTo.add(path);
                    }
                }
            }
        }

        //        // Individual zone overrides
        //        final String[] overrides = {
        //            "Pacific/Honolulu\"]/short/generic",
        //            "Pacific/Honolulu\"]/short/standard",
        //            "Pacific/Honolulu\"]/short/daylight",
        //            "Europe/Dublin\"]/long/daylight",
        //            "Europe/London\"]/long/daylight",
        //            "Etc/UTC\"]/long/standard",
        //            "Etc/UTC\"]/short/standard"
        //        };
        //        for (String override : overrides) {
        //            toAddTo.add("//ldml/dates/timeZoneNames/zone[@type=\"" + override);
        //        }

        // Currencies
        Set<String> codes = supplementalData.getBcp47Keys().getAll("cu");
        for (String code : codes) {
            String currencyCode = code.toUpperCase();
            toAddTo.add(
                    "//ldml/numbers/currencies/currency[@type=\"" + currencyCode + "\"]/symbol");
            toAddTo.add(
                    "//ldml/numbers/currencies/currency[@type=\""
                            + currencyCode
                            + "\"]/displayName");
            if (!pluralCounts.isEmpty()) {
                for (Count count : pluralCounts) {
                    toAddTo.add(
                            "//ldml/numbers/currencies/currency[@type=\""
                                    + currencyCode
                                    + "\"]/displayName[@count=\""
                                    + count.toString()
                                    + "\"]");
                }
            }
        }

        // grammatical info

        GrammarInfo grammarInfo = supplementalData.getGrammarInfo(getLocaleID(), true);
        if (grammarInfo != null) {
            if (grammarInfo.hasInfo(GrammaticalTarget.nominal)) {
                Collection<String> genders =
                        grammarInfo.get(
                                GrammaticalTarget.nominal,
                                GrammaticalFeature.grammaticalGender,
                                GrammaticalScope.units);
                Collection<String> rawCases =
                        grammarInfo.get(
                                GrammaticalTarget.nominal,
                                GrammaticalFeature.grammaticalCase,
                                GrammaticalScope.units);
                Collection<String> nomCases = rawCases.isEmpty() ? casesNominativeOnly : rawCases;
                Collection<Count> adjustedPlurals = pluralCounts;
                // There was code here allowing fewer plurals to be used, but is retracted for now
                // (needs more thorough integration in logical groups, etc.)
                // This note is left for 'blame' to find the old code in case we revive that.

                // TODO use UnitPathType to get paths
                if (!genders.isEmpty()) {
                    for (String unit : GrammarInfo.getUnitsToAddGrammar()) {
                        toAddTo.add(
                                "//ldml/units/unitLength[@type=\"long\"]/unit[@type=\""
                                        + unit
                                        + "\"]/gender");
                    }
                    for (Count plural : adjustedPlurals) {
                        for (String gender : genders) {
                            for (String case1 : nomCases) {
                                final String grammaticalAttributes =
                                        GrammarInfo.getGrammaticalInfoAttributes(
                                                grammarInfo,
                                                UnitPathType.power,
                                                plural.toString(),
                                                gender,
                                                case1);
                                toAddTo.add(
                                        "//ldml/units/unitLength[@type=\"long\"]/compoundUnit[@type=\"power2\"]/compoundUnitPattern1"
                                                + grammaticalAttributes);
                                toAddTo.add(
                                        "//ldml/units/unitLength[@type=\"long\"]/compoundUnit[@type=\"power3\"]/compoundUnitPattern1"
                                                + grammaticalAttributes);
                            }
                        }
                    }
                    //             <genderMinimalPairs gender="masculine">Der {0} ist
                    // …</genderMinimalPairs>
                    for (String gender : genders) {
                        toAddTo.add(
                                "//ldml/numbers/minimalPairs/genderMinimalPairs[@gender=\""
                                        + gender
                                        + "\"]");
                    }
                }
                if (!rawCases.isEmpty()) {
                    for (String case1 : rawCases) {
                        //          <caseMinimalPairs case="nominative">{0} kostet
                        // €3,50.</caseMinimalPairs>
                        toAddTo.add(
                                "//ldml/numbers/minimalPairs/caseMinimalPairs[@case=\""
                                        + case1
                                        + "\"]");

                        for (Count plural : adjustedPlurals) {
                            for (String unit : GrammarInfo.getUnitsToAddGrammar()) {
                                toAddTo.add(
                                        "//ldml/units/unitLength[@type=\"long\"]/unit[@type=\""
                                                + unit
                                                + "\"]/unitPattern"
                                                + GrammarInfo.getGrammaticalInfoAttributes(
                                                        grammarInfo,
                                                        UnitPathType.unit,
                                                        plural.toString(),
                                                        null,
                                                        case1));
                            }
                        }
                    }
                }
            }
        }
        return toAddTo.stream().map(String::intern).collect(Collectors.toList());
    }

    private void addPluralCounts(
            Collection<String> toAddTo,
            final Set<Count> pluralCounts,
            final Set<Count> pluralCountsRaw,
            Iterable<String> file) {
        for (String path : file) {
            String countAttr = "[@count=\"other\"]";
            int countPos = path.indexOf(countAttr);
            if (countPos < 0) {
                continue;
            }
            Set<Count> pluralCountsNeeded =
                    path.startsWith("//ldml/numbers/minimalPairs") ? pluralCountsRaw : pluralCounts;
            if (pluralCountsNeeded.size() > 1) {
                String start = path.substring(0, countPos) + "[@count=\"";
                String end = "\"]" + path.substring(countPos + countAttr.length());
                for (Count count : pluralCounts) {
                    if (count == Count.other) {
                        continue;
                    }
                    toAddTo.add(start + count + end);
                }
            }
        }
    }

    /**
     * Get the path with the given count, case, or gender, with fallback. The fallback acts like an
     * alias in root.
     *
     * <p>Count:
     *
     * <p>It acts like there is an alias in root from count=n to count=one, then for currency
     * display names from count=one to no count <br>
     * For unitPatterns, falls back to Count.one. <br>
     * For others, falls back to Count.one, then no count.
     *
     * <p>Case
     *
     * <p>The fallback is to no case, which = nominative.
     *
     * <p>Case
     *
     * <p>The fallback is to no case, which = nominative.
     *
     * @param xpath
     * @param count Count may be null. Returns null if nothing is found.
     * @param winning TODO
     * @return
     */
    public String getCountPathWithFallback(String xpath, Count count, boolean winning) {
        String result;
        XPathParts parts =
                XPathParts.getFrozenInstance(xpath)
                        .cloneAsThawed(); // not frozen, addAttribute in getCountPathWithFallback2

        // In theory we should do all combinations of gender, case, count (and eventually
        // definiteness), but for simplicity
        // we just successively try "zeroing" each one in a set order.
        // tryDefault modifies the parts in question
        Output<String> newPath = new Output<>();
        if (tryDefault(parts, "gender", null, newPath)) {
            return newPath.value;
        }

        if (tryDefault(parts, "case", null, newPath)) {
            return newPath.value;
        }

        boolean isDisplayName = parts.contains("displayName");

        String actualCount = parts.getAttributeValue(-1, "count");
        if (actualCount != null) {
            if (CldrUtility.DIGITS.containsAll(actualCount)) {
                try {
                    int item = Integer.parseInt(actualCount);
                    String locale = getLocaleID();
                    SupplementalDataInfo sdi = CLDRConfig.getInstance().getSupplementalDataInfo();
                    PluralRules rules =
                            sdi.getPluralRules(
                                    new ULocale(locale), PluralRules.PluralType.CARDINAL);
                    String keyword = rules.select(item);
                    Count itemCount = Count.valueOf(keyword);
                    result = getCountPathWithFallback2(parts, xpath, itemCount, winning);
                    if (result != null && isNotRoot(result)) {
                        return result;
                    }
                } catch (NumberFormatException e) {
                }
            }

            // try the given count first
            result = getCountPathWithFallback2(parts, xpath, count, winning);
            if (result != null && isNotRoot(result)) {
                return result;
            }
            // now try fallback
            if (count != Count.other) {
                result = getCountPathWithFallback2(parts, xpath, Count.other, winning);
                if (result != null && isNotRoot(result)) {
                    return result;
                }
            }
            // now try deletion (for currency)
            if (isDisplayName) {
                result = getCountPathWithFallback2(parts, xpath, null, winning);
            }
            return result;
        }
        return null;
    }

    /**
     * Modify the parts by setting the attribute in question to the default value (typically null to
     * clear). If there is a value for that path, use it.
     */
    public boolean tryDefault(
            XPathParts parts, String attribute, String defaultValue, Output<String> newPath) {
        String oldValue = parts.getAttributeValue(-1, attribute);
        if (oldValue != null) {
            parts.setAttribute(-1, attribute, null);
            newPath.value = parts.toString();
            if (dataSource.getValueAtPath(newPath.value) != null) {
                return true;
            }
        }
        return false;
    }

    private String getCountPathWithFallback2(
            XPathParts parts, String xpathWithNoCount, Count count, boolean winning) {
        parts.addAttribute("count", count == null ? null : count.toString());
        String newPath = parts.toString();
        if (!newPath.equals(xpathWithNoCount)) {
            if (winning) {
                String temp = getWinningPath(newPath);
                if (temp != null) {
                    newPath = temp;
                }
            }
            if (dataSource.getValueAtPath(newPath) != null) {
                return newPath;
            }
            // return getWinningPath(newPath);
        }
        return null;
    }

    /**
     * Returns a value to be used for "filling in" a "Change" value in the survey tool. Currently
     * returns the following.
     *
     * <ul>
     *   <li>The "winning" value (if not inherited). Example: if "Donnerstag" has the most votes for
     *       'thursday', then clicking on the empty field will fill in "Donnerstag"
     *   <li>The singular form. Example: if the value for 'hour' is "heure", then clicking on the
     *       entry field for 'hours' will insert "heure".
     *   <li>The parent's value. Example: if I'm in [de_CH] and there are no proposals for
     *       'thursday', then clicking on the empty field will fill in "Donnerstag" from [de].
     *   <li>Otherwise don't fill in anything, and return null.
     * </ul>
     *
     * @return
     */
    public String getFillInValue(String distinguishedPath) {
        String winningPath = getWinningPath(distinguishedPath);
        if (isNotRoot(winningPath)) {
            return getStringValue(winningPath);
        }
        String fallbackPath = getFallbackPath(winningPath, true, true);
        if (fallbackPath != null) {
            String value = getWinningValue(fallbackPath);
            if (value != null) {
                return value;
            }
        }
        return getStringValue(winningPath);
    }

    /**
     * returns true if the source of the path exists, and is neither root nor code-fallback
     *
     * @param distinguishedPath
     * @return
     */
    public boolean isNotRoot(String distinguishedPath) {
        String source = getSourceLocaleID(distinguishedPath, null);
        return source != null
                && !source.equals("root")
                && !source.equals(XMLSource.CODE_FALLBACK_ID);
    }

    public boolean isAliasedAtTopLevel() {
        return iterator("//ldml/alias").hasNext();
    }

    public static Comparator<String> getComparator(DtdType dtdType) {
        if (dtdType == null) {
            return ldmlComparator;
        }
        switch (dtdType) {
            case ldml:
            case ldmlICU:
                return ldmlComparator;
            default:
                return DtdData.getInstance(dtdType).getDtdComparator(null);
        }
    }

    public Comparator<String> getComparator() {
        return getComparator(dtdType);
    }

    public DtdType getDtdType() {
        return dtdType != null ? dtdType : dataSource.getDtdType();
    }

    public DtdData getDtdData() {
        return dtdData != null ? dtdData : DtdData.getInstance(getDtdType());
    }

    public static Comparator<String> getPathComparator(String path) {
        DtdType fileDtdType = DtdType.fromPath(path);
        return getComparator(fileDtdType);
    }

    public static MapComparator<String> getAttributeOrdering() {
        return DtdData.getInstance(DtdType.ldmlICU).getAttributeComparator();
    }

    public CLDRFile getUnresolved() {
        if (!isResolved()) {
            return this;
        }
        XMLSource source = dataSource.getUnresolving();
        return new CLDRFile(source);
    }

    public static Comparator<String> getAttributeValueComparator(String element, String attribute) {
        return DtdData.getAttributeValueComparator(DtdType.ldml, element, attribute);
    }

    public void setDtdType(DtdType dtdType) {
        if (locked) throw new UnsupportedOperationException("Attempt to modify locked object");
        this.dtdType = dtdType;
    }

    public void disableCaching() {
        dataSource.disableCaching();
    }

    /**
     * Get a constructed value for the given path, if it is a path for which values can be
     * constructed
     *
     * @param xpath the given path, such as
     *     //ldml/localeDisplayNames/languages/language[@type="zh_Hans"]
     * @return the constructed value, or null if this path doesn't have a constructed value
     */
    public String getConstructedValue(String xpath) {
        if (isResolved() && GlossonymConstructor.pathIsEligible(xpath)) {
            return new GlossonymConstructor(this).getValue(xpath);
        }
        return null;
    }

    /**
     * Get the string value for the given path in this locale, without resolving to any other path
     * or locale.
     *
     * @param xpath the given path
     * @return the string value, unresolved
     */
    private String getStringValueUnresolved(String xpath) {
        CLDRFile sourceFileUnresolved = this.getUnresolved();
        return sourceFileUnresolved.getStringValue(xpath);
    }

    /**
     * Create an overriding LocaleStringProvider for testing and example generation
     *
     * @param pathAndValueOverrides
     * @return
     */
    public LocaleStringProvider makeOverridingStringProvider(
            Map<String, String> pathAndValueOverrides) {
        return new OverridingStringProvider(pathAndValueOverrides);
    }

    public class OverridingStringProvider implements LocaleStringProvider {
        private final Map<String, String> pathAndValueOverrides;

        public OverridingStringProvider(Map<String, String> pathAndValueOverrides) {
            this.pathAndValueOverrides = pathAndValueOverrides;
        }

        @Override
        public String getStringValue(String xpath) {
            String value = pathAndValueOverrides.get(xpath);
            return value != null ? value : CLDRFile.this.getStringValue(xpath);
        }

        @Override
        public String getLocaleID() {
            return CLDRFile.this.getLocaleID();
        }

        @Override
        public String getSourceLocaleID(String xpath, Status status) {
            if (pathAndValueOverrides.containsKey(xpath)) {
                if (status != null) {
                    status.pathWhereFound = xpath;
                }
                return getLocaleID() + "-override";
            }
            return CLDRFile.this.getSourceLocaleID(xpath, status);
        }
    }

    public String getKeyName(String key) {
        String result = getStringValue("//ldml/localeDisplayNames/keys/key[@type=\"" + key + "\"]");
        if (result == null) {
            Relation<R2<String, String>, String> toAliases =
                    SupplementalDataInfo.getInstance().getBcp47Aliases();
            Set<String> aliases = toAliases.get(Row.of(key, ""));
            if (aliases != null) {
                for (String alias : aliases) {
                    result =
                            getStringValue(
                                    "//ldml/localeDisplayNames/keys/key[@type=\"" + alias + "\"]");
                    if (result != null) {
                        break;
                    }
                }
            }
        }
        return result;
    }

    public String getKeyValueName(String key, String value) {
        String result =
                getStringValue(
                        "//ldml/localeDisplayNames/types/type[@key=\""
                                + key
                                + "\"][@type=\""
                                + value
                                + "\"]");
        if (result == null) {
            Relation<R2<String, String>, String> toAliases =
                    SupplementalDataInfo.getInstance().getBcp47Aliases();
            Set<String> keyAliases = toAliases.get(Row.of(key, ""));
            Set<String> valueAliases = toAliases.get(Row.of(key, value));
            if (keyAliases != null || valueAliases != null) {
                if (keyAliases == null) {
                    keyAliases = Collections.singleton(key);
                }
                if (valueAliases == null) {
                    valueAliases = Collections.singleton(value);
                }
                for (String keyAlias : keyAliases) {
                    for (String valueAlias : valueAliases) {
                        result =
                                getStringValue(
                                        "//ldml/localeDisplayNames/types/type[@key=\""
                                                + keyAlias
                                                + "\"][@type=\""
                                                + valueAlias
                                                + "\"]");
                        if (result != null) {
                            break;
                        }
                    }
                }
            }
        }
        return result;
    }

    /*
     *******************************************************************************************
     * TODO: move the code below here -- that is, the many (currently ten as of 2022-06-01)
     * versions of getName and their subroutines and data -- to a new class in a separate file,
     * and enable tracking similar to existing "pathWhereFound/localeWhereFound" but more general.
     *
     * Reference: https://unicode-org.atlassian.net/browse/CLDR-15830
     *******************************************************************************************
     */

    static final Joiner JOIN_HYPHEN = Joiner.on('-');
    static final Joiner JOIN_UNDERBAR = Joiner.on('_');

    /** Utility for getting a name, given a type and code. */
    public String getName(String type, String code) {
        return getName(typeNameToCode(type), code);
    }

    public String getName(int type, String code) {
        return getName(type, code, null, null);
    }

    public String getName(int type, String code, Set<String> paths) {
        return getName(type, code, null, paths);
    }

    public String getName(int type, String code, Transform<String, String> altPicker) {
        return getName(type, code, altPicker, null);
    }

    /**
     * Returns the name of the given bcp47 identifier. Note that extensions must be specified using
     * the old "\@key=type" syntax.
     *
     * @param localeOrTZID
     * @return
     */
    public synchronized String getName(String localeOrTZID) {
        return getName(localeOrTZID, false);
    }

    public String getName(
            LanguageTagParser lparser,
            boolean onlyConstructCompound,
            Transform<String, String> altPicker) {
        return getName(lparser, onlyConstructCompound, altPicker, null);
    }

    /**
     * @param paths if non-null, will contain contributory paths on return
     */
    public String getName(
            LanguageTagParser lparser,
            boolean onlyConstructCompound,
            Transform<String, String> altPicker,
            Set<String> paths) {
        return getName(
                lparser,
                onlyConstructCompound,
                altPicker,
                getWinningValueWithBailey(GETNAME_LOCALE_KEY_TYPE_PATTERN),
                getWinningValueWithBailey(GETNAME_LOCALE_PATTERN),
                getWinningValueWithBailey(GETNAME_LOCALE_SEPARATOR),
                paths);
    }

    public synchronized String getName(
            String localeOrTZID,
            boolean onlyConstructCompound,
            String localeKeyTypePattern,
            String localePattern,
            String localeSeparator) {
        return getName(
                localeOrTZID,
                onlyConstructCompound,
                localeKeyTypePattern,
                localePattern,
                localeSeparator,
                null,
                null);
    }

    /**
     * Returns the name of the given bcp47 identifier. Note that extensions must be specified using
     * the old "\@key=type" syntax.
     *
     * @param localeOrTZID the locale or timezone ID
     * @param onlyConstructCompound
     * @return
     */
    public synchronized String getName(String localeOrTZID, boolean onlyConstructCompound) {
        return getName(localeOrTZID, onlyConstructCompound, null);
    }

    /**
     * Returns the name of the given bcp47 identifier. Note that extensions must be specified using
     * the old "\@key=type" syntax.
     *
     * @param localeOrTZID the locale or timezone ID
     * @param onlyConstructCompound if true, returns "English (United Kingdom)" instead of "British
     *     English"
     * @param altPicker Used to select particular alts. For example, SHORT_ALTS can be used to get
     *     "English (U.K.)" instead of "English (United Kingdom)"
     * @return
     */
    public synchronized String getName(
            String localeOrTZID,
            boolean onlyConstructCompound,
            Transform<String, String> altPicker) {
        return getName(localeOrTZID, onlyConstructCompound, altPicker, null);
    }

    /**
     * Returns the name of the given bcp47 identifier. Note that extensions must be specified using
     * the old "\@key=type" syntax.
     *
     * @param localeOrTZID the locale or timezone ID
     * @param onlyConstructCompound if true, returns "English (United Kingdom)" instead of "British
     *     English"
     * @param altPicker Used to select particular alts. For example, SHORT_ALTS can be used to get
     *     "English (U.K.)" instead of "English (United Kingdom)"
     * @return
     */
    public synchronized String getName(
            String localeOrTZID,
            boolean onlyConstructCompound,
            Transform<String, String> altPicker,
            Set<String> paths) {
        return getName(
                localeOrTZID,
                onlyConstructCompound,
                getWinningValueWithBailey(GETNAME_LOCALE_KEY_TYPE_PATTERN),
                getWinningValueWithBailey(GETNAME_LOCALE_PATTERN),
                getWinningValueWithBailey(GETNAME_LOCALE_SEPARATOR),
                altPicker,
                paths);
    }

    /**
     * Returns the name of the given bcp47 identifier. Note that extensions must be specified using
     * the old "\@key=type" syntax. Only used by ExampleGenerator.
     *
     * @param localeOrTZID the locale or timezone ID
     * @param onlyConstructCompound
     * @param localeKeyTypePattern the pattern used to format key-type pairs
     * @param localePattern the pattern used to format primary/secondary subtags
     * @param localeSeparator the list separator for secondary subtags
     * @param paths if non-null, fillin with contributory paths
     * @return
     */
    public synchronized String getName(
            String localeOrTZID,
            boolean onlyConstructCompound,
            String localeKeyTypePattern,
            String localePattern,
            String localeSeparator,
            Transform<String, String> altPicker,
            Set<String> paths) {
        // Hack for seed
        if (localePattern == null) {
            localePattern = "{0} ({1})";
        }
        boolean isCompound = localeOrTZID.contains("_");
        String name =
                isCompound && onlyConstructCompound
                        ? null
                        : getName(LANGUAGE_NAME, localeOrTZID, altPicker, paths);

        // TODO - handle arbitrary combinations
        if (name != null && !name.contains("_") && !name.contains("-")) {
            name = replaceBracketsForName(name);
            return name;
        }
        LanguageTagParser lparser = new LanguageTagParser().set(localeOrTZID);
        return getName(
                lparser,
                onlyConstructCompound,
                altPicker,
                localeKeyTypePattern,
                localePattern,
                localeSeparator,
                paths);
    }

    public String getName(
            LanguageTagParser lparser,
            boolean onlyConstructCompound,
            Transform<String, String> altPicker,
            String localeKeyTypePattern,
            String localePattern,
            String localeSeparator,
            Set<String> paths) {
        String name;
        String original = null;

        // we need to check for prefixes, for lang+script or lang+country
        boolean haveScript = false;
        boolean haveRegion = false;
        // try lang+script
        if (onlyConstructCompound) {
            name = getName(LANGUAGE_NAME, original = lparser.getLanguage(), altPicker, paths);
            if (name == null) name = original;
        } else {
            String x = lparser.toString(LanguageTagParser.LANGUAGE_SCRIPT_REGION);
            name = getName(LANGUAGE_NAME, x, altPicker, paths);
            if (name != null) {
                haveScript = haveRegion = true;
            } else {
                name =
                        getName(
                                LANGUAGE_NAME,
                                lparser.toString(LanguageTagParser.LANGUAGE_SCRIPT),
                                altPicker,
                                paths);
                if (name != null) {
                    haveScript = true;
                } else {
                    name =
                            getName(
                                    LANGUAGE_NAME,
                                    lparser.toString(LanguageTagParser.LANGUAGE_REGION),
                                    altPicker,
                                    paths);
                    if (name != null) {
                        haveRegion = true;
                    } else {
                        name =
                                getName(
                                        LANGUAGE_NAME,
                                        original = lparser.getLanguage(),
                                        altPicker,
                                        paths);
                        if (name == null) {
                            name = original;
                        }
                    }
                }
            }
        }
        name = replaceBracketsForName(name);
        String extras = "";
        if (!haveScript) {
            extras =
                    addDisplayName(
                            lparser.getScript(),
                            SCRIPT_NAME,
                            localeSeparator,
                            extras,
                            altPicker,
                            paths);
        }
        if (!haveRegion) {
            extras =
                    addDisplayName(
                            lparser.getRegion(),
                            TERRITORY_NAME,
                            localeSeparator,
                            extras,
                            altPicker,
                            paths);
        }
        List<String> variants = lparser.getVariants();
        for (String orig : variants) {
            extras = addDisplayName(orig, VARIANT_NAME, localeSeparator, extras, altPicker, paths);
        }

        // Look for key-type pairs.
        main:
        for (Map.Entry<String, List<String>> extension :
                lparser.getLocaleExtensionsDetailed().entrySet()) {
            String key = extension.getKey();
            if (key.equals("h0")) {
                continue;
            }
            List<String> keyValue = extension.getValue();
            String oldFormatType =
                    (key.equals("ca") ? JOIN_HYPHEN : JOIN_UNDERBAR)
                            .join(keyValue); // default value
            // Check if key/type pairs exist in the CLDRFile first.
            String value = getKeyValueName(key, oldFormatType);
            if (value != null) {
                value = replaceBracketsForName(value);
            } else {
                // if we fail, then we construct from the key name and the value
                String kname = getKeyName(key);
                if (kname == null) {
                    kname = key; // should not happen, but just in case
                }
                switch (key) {
                    case "t":
                        List<String> hybrid = lparser.getLocaleExtensionsDetailed().get("h0");
                        if (hybrid != null) {
                            kname = getKeyValueName("h0", JOIN_UNDERBAR.join(hybrid));
                        }
                        oldFormatType = getName(oldFormatType);
                        break;
                    case "h0":
                        continue main;
                    case "cu":
                        oldFormatType =
                                getName(
                                        CURRENCY_SYMBOL,
                                        oldFormatType.toUpperCase(Locale.ROOT),
                                        paths);
                        break;
                    case "tz":
                        if (paths != null) {
                            throw new IllegalArgumentException(
                                    "Error: getName(…) with paths doesn't handle timezones.");
                        }
                        oldFormatType =
                                getTZName(
                                        oldFormatType, "VVVV"); // TODO: paths not handled here, yet
                        break;
                    case "kr":
                        oldFormatType = getReorderName(localeSeparator, keyValue, paths);
                        break;
                    case "rg":
                    case "sd":
                        oldFormatType = getName(SUBDIVISION_NAME, oldFormatType, paths);
                        break;
                    default:
                        oldFormatType = JOIN_HYPHEN.join(keyValue);
                }
                value =
                        MessageFormat.format(
                                localeKeyTypePattern, new Object[] {kname, oldFormatType});
                if (paths != null) {
                    paths.add(GETNAME_LOCALE_KEY_TYPE_PATTERN);
                }
                value = replaceBracketsForName(value);
            }
            if (paths != null && !extras.isEmpty()) {
                paths.add(GETNAME_LOCALE_SEPARATOR);
            }
            extras =
                    extras.isEmpty()
                            ? value
                            : MessageFormat.format(localeSeparator, new Object[] {extras, value});
        }
        // now handle stray extensions
        for (Map.Entry<String, List<String>> extension :
                lparser.getExtensionsDetailed().entrySet()) {
            String value =
                    MessageFormat.format(
                            localeKeyTypePattern,
                            new Object[] {
                                extension.getKey(), JOIN_HYPHEN.join(extension.getValue())
                            });
            if (paths != null) {
                paths.add(GETNAME_LOCALE_KEY_TYPE_PATTERN);
            }
            extras =
                    extras.isEmpty()
                            ? value
                            : MessageFormat.format(localeSeparator, new Object[] {extras, value});
        }
        // fix this -- shouldn't be hardcoded!
        if (extras.length() == 0) {
            return name;
        }
        if (paths != null) {
            paths.add(GETNAME_LOCALE_PATTERN);
        }
        return MessageFormat.format(localePattern, new Object[] {name, extras});
    }

    private static final String replaceBracketsForName(String value) {
        value = value.replace('(', '[').replace(')', ']').replace('（', '［').replace('）', '］');
        return value;
    }

    /**
     * Utility for getting the name, given a code.
     *
     * @param type
     * @param code
     * @param codeToAlt - if not null, is called on the code. If the result is not null, then that
     *     is used for an alt value. If the alt path has a value it is used, otherwise the normal
     *     one is used. For example, the transform could return "short" for PS or HK or MO, but not
     *     US or GB.
     * @param paths if non-null, will have contributory paths on return
     * @return
     */
    public String getName(
            int type, String code, Transform<String, String> codeToAlt, Set<String> paths) {
        String path = getKey(type, code);
        String result = null;
        if (codeToAlt != null) {
            String alt = codeToAlt.transform(code);
            if (alt != null) {
                String altPath = path + "[@alt=\"" + alt + "\"]";
                result = getStringValueWithBaileyNotConstructed(altPath);
                if (paths != null && result != null) {
                    paths.add(altPath);
                }
            }
        }
        if (result == null) {
            result = getStringValueWithBaileyNotConstructed(path);
            if (paths != null && result != null) {
                paths.add(path);
            }
        }
        if (getLocaleID().equals("en")) {
            CLDRFile.Status status = new CLDRFile.Status();
            String sourceLocale = getSourceLocaleID(path, status);
            if (result == null || !sourceLocale.equals("en")) {
                if (type == LANGUAGE_NAME) {
                    Set<String> set = Iso639Data.getNames(code);
                    if (set != null) {
                        return set.iterator().next();
                    }
                    Map<String, Map<String, String>> map =
                            StandardCodes.getLStreg().get("language");
                    Map<String, String> info = map.get(code);
                    if (info != null) {
                        result = info.get("Description");
                    }
                } else if (type == TERRITORY_NAME) {
                    result = getLstrFallback("region", code, paths);
                } else if (type == SCRIPT_NAME) {
                    result = getLstrFallback("script", code, paths);
                }
            }
        }
        return result;
    }

    static final Pattern CLEAN_DESCRIPTION = Pattern.compile("([^\\(\\[]*)[\\(\\[].*");
    static final Splitter DESCRIPTION_SEP = Splitter.on('▪');

    private String getLstrFallback(String codeType, String code, Set<String> paths) {
        Map<String, String> info = StandardCodes.getLStreg().get(codeType).get(code);
        if (info != null) {
            String temp = info.get("Description");
            if (!temp.equalsIgnoreCase("Private use")) {
                List<String> temp2 = DESCRIPTION_SEP.splitToList(temp);
                temp = temp2.get(0);
                final Matcher matcher = CLEAN_DESCRIPTION.matcher(temp);
                if (matcher.lookingAt()) {
                    temp = matcher.group(1).trim();
                }
                return temp;
            }
        }
        return null;
    }

    /**
     * Gets timezone name. Not optimized.
     *
     * @param tzcode
     * @return
     */
    private String getTZName(String tzcode, String format) {
        String longid = getLongTzid(tzcode);
        if (tzcode.length() == 4 && !tzcode.equals("gaza")) {
            return longid;
        }
        TimezoneFormatter tzf = new TimezoneFormatter(this);
        return tzf.getFormattedZone(longid, format, 0);
    }

    private String getReorderName(
            String localeSeparator, List<String> keyValues, Set<String> paths) {
        String result = null;
        for (String value : keyValues) {
            String name =
                    getName(
                            SCRIPT_NAME,
                            Character.toUpperCase(value.charAt(0)) + value.substring(1),
                            paths);
            if (name == null) {
                name = getKeyValueName("kr", value);
                if (name == null) {
                    name = value;
                }
            }
            result =
                    result == null
                            ? name
                            : MessageFormat.format(localeSeparator, new Object[] {result, name});
        }
        return result;
    }

    /**
     * Adds the display name for a subtag to a string.
     *
     * @param subtag the subtag
     * @param type the type of the subtag
     * @param separatorPattern the pattern to be used for separating display names in the resultant
     *     string
     * @param extras the string to be added to
     * @return the modified display name string
     */
    private String addDisplayName(
            String subtag,
            int type,
            String separatorPattern,
            String extras,
            Transform<String, String> altPicker,
            Set<String> paths) {
        if (subtag.length() == 0) {
            return extras;
        }
        String sname = getName(type, subtag, altPicker, paths);
        if (sname == null) {
            sname = subtag;
        }
        sname = replaceBracketsForName(sname);

        if (extras.length() == 0) {
            extras += sname;
        } else {
            extras = MessageFormat.format(separatorPattern, new Object[] {extras, sname});
        }
        return extras;
    }

    /**
     * Like getStringValueWithBailey, but reject constructed values, to prevent circularity problems
     * with getName
     *
     * <p>Since GlossonymConstructor uses getName to CREATE constructed values, circularity problems
     * would occur if getName in turn used GlossonymConstructor to get constructed Bailey values.
     * Note that getStringValueWithBailey only returns a constructed value if the value would
     * otherwise be "bogus", and getName has no use for bogus values, so there is no harm in
     * returning null rather than code-fallback or other bogus values.
     *
     * @param path the given xpath
     * @return the string value, or null
     */
    private String getStringValueWithBaileyNotConstructed(String path) {
        Output<String> pathWhereFound = new Output<>();
        final String value = getStringValueWithBailey(path, pathWhereFound, null);
        if (value == null || GlossonymConstructor.PSEUDO_PATH.equals(pathWhereFound.toString())) {
            return null;
        }
        return value;
    }

    /**
     * A set of paths to be added to getRawExtraPaths(). These are constant across locales, and
     * don't have good fallback values in root. NOTE: if this is changed, you'll need to modify
     * TestPaths.extraPathAllowsNullValue
     */
    static final Set<String> CONST_EXTRA_PATHS =
            CharUtilities.internImmutableSet(
                    Set.of(
                            // Individual zone overrides — were in getRawExtraPaths
                            "//ldml/dates/timeZoneNames/zone[@type=\"Pacific/Honolulu\"]/short/generic",
                            "//ldml/dates/timeZoneNames/zone[@type=\"Pacific/Honolulu\"]/short/standard",
                            "//ldml/dates/timeZoneNames/zone[@type=\"Pacific/Honolulu\"]/short/daylight",
                            "//ldml/dates/timeZoneNames/zone[@type=\"Europe/Dublin\"]/long/daylight",
                            "//ldml/dates/timeZoneNames/zone[@type=\"Europe/London\"]/long/daylight",
                            "//ldml/dates/timeZoneNames/zone[@type=\"Etc/UTC\"]/long/standard",
                            "//ldml/dates/timeZoneNames/zone[@type=\"Etc/UTC\"]/short/standard",
                            // Person name paths
                            "//ldml/personNames/sampleName[@item=\"nativeG\"]/nameField[@type=\"given\"]",
                            "//ldml/personNames/sampleName[@item=\"nativeGS\"]/nameField[@type=\"given\"]",
                            "//ldml/personNames/sampleName[@item=\"nativeGS\"]/nameField[@type=\"surname\"]",
                            "//ldml/personNames/sampleName[@item=\"nativeGGS\"]/nameField[@type=\"given\"]",
                            "//ldml/personNames/sampleName[@item=\"nativeGGS\"]/nameField[@type=\"given2\"]",
                            "//ldml/personNames/sampleName[@item=\"nativeGGS\"]/nameField[@type=\"surname\"]",
                            "//ldml/personNames/sampleName[@item=\"nativeFull\"]/nameField[@type=\"title\"]",
                            "//ldml/personNames/sampleName[@item=\"nativeFull\"]/nameField[@type=\"given\"]",
                            "//ldml/personNames/sampleName[@item=\"nativeFull\"]/nameField[@type=\"given-informal\"]",
                            "//ldml/personNames/sampleName[@item=\"nativeFull\"]/nameField[@type=\"given2\"]",
                            "//ldml/personNames/sampleName[@item=\"nativeFull\"]/nameField[@type=\"surname-prefix\"]",
                            "//ldml/personNames/sampleName[@item=\"nativeFull\"]/nameField[@type=\"surname-core\"]",
                            "//ldml/personNames/sampleName[@item=\"nativeFull\"]/nameField[@type=\"surname2\"]",
                            "//ldml/personNames/sampleName[@item=\"nativeFull\"]/nameField[@type=\"generation\"]",
                            "//ldml/personNames/sampleName[@item=\"nativeFull\"]/nameField[@type=\"credentials\"]",
                            "//ldml/personNames/sampleName[@item=\"foreignG\"]/nameField[@type=\"given\"]",
                            "//ldml/personNames/sampleName[@item=\"foreignGS\"]/nameField[@type=\"given\"]",
                            "//ldml/personNames/sampleName[@item=\"foreignGS\"]/nameField[@type=\"surname\"]",
                            "//ldml/personNames/sampleName[@item=\"foreignGGS\"]/nameField[@type=\"given\"]",
                            "//ldml/personNames/sampleName[@item=\"foreignGGS\"]/nameField[@type=\"given2\"]",
                            "//ldml/personNames/sampleName[@item=\"foreignGGS\"]/nameField[@type=\"surname\"]",
                            "//ldml/personNames/sampleName[@item=\"foreignFull\"]/nameField[@type=\"title\"]",
                            "//ldml/personNames/sampleName[@item=\"foreignFull\"]/nameField[@type=\"given\"]",
                            "//ldml/personNames/sampleName[@item=\"foreignFull\"]/nameField[@type=\"given-informal\"]",
                            "//ldml/personNames/sampleName[@item=\"foreignFull\"]/nameField[@type=\"given2\"]",
                            "//ldml/personNames/sampleName[@item=\"foreignFull\"]/nameField[@type=\"surname-prefix\"]",
                            "//ldml/personNames/sampleName[@item=\"foreignFull\"]/nameField[@type=\"surname-core\"]",
                            "//ldml/personNames/sampleName[@item=\"foreignFull\"]/nameField[@type=\"surname2\"]",
                            "//ldml/personNames/sampleName[@item=\"foreignFull\"]/nameField[@type=\"generation\"]",
                            "//ldml/personNames/sampleName[@item=\"foreignFull\"]/nameField[@type=\"credentials\"]"));
}