android-14.0.0_r21/s

package org.unicode.cldr.util.personname;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.EnumSet;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Objects;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.regex.Pattern;

import org.unicode.cldr.util.CLDRFile;
import org.unicode.cldr.util.ChainedMap;
import org.unicode.cldr.util.ChainedMap.M3;
import org.unicode.cldr.util.LanguageTagParser;
import org.unicode.cldr.util.Pair;
import org.unicode.cldr.util.XPathParts;

import com.google.common.base.Joiner;
import com.google.common.base.Splitter;
import com.google.common.collect.Comparators;
import com.google.common.collect.ComparisonChain;
import com.google.common.collect.ImmutableBiMap;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableListMultimap;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.LinkedListMultimap;
import com.google.common.collect.ListMultimap;
import com.google.common.collect.Maps;
import com.google.common.collect.Multimap;
import com.google.common.collect.Multiset;
import com.google.common.collect.TreeMultimap;
import com.google.common.collect.TreeMultiset;
import com.ibm.icu.lang.UCharacter;
import com.ibm.icu.text.BreakIterator;
import com.ibm.icu.text.CaseMap;
import com.ibm.icu.text.MessageFormat;
import com.ibm.icu.util.Output;
import com.ibm.icu.util.ULocale;

/**
 * Rough sketch for now
 * TODO Mark Make classes/methods private that don't need to be public
 * TODO Peter Check for invalid parameters
 */

public class PersonNameFormatter {

    public static final boolean DEBUG = System.getProperty("PersonNameFormatter.DEBUG") != null;

    public enum Field {
        prefix,
        given,
        given2,
        surname,
        surname2,
        suffix;
        public static final Comparator<Iterable<Field>> ITERABLE_COMPARE = Comparators.lexicographical(Comparator.<Field>naturalOrder());
        public static final Set<Field> ALL = ImmutableSet.copyOf(Field.values());
    }

    public enum Order {
        givenFirst,
        surnameFirst,
        sorting;
        public static final Comparator<Iterable<Order>> ITERABLE_COMPARE = Comparators.lexicographical(Comparator.<Order>naturalOrder());
        public static final Set<Order> ALL = ImmutableSet.copyOf(Order.values());
        /**
         * Use this instead of valueOf if value might be null
         */
        public static Order from(String item) {
            return item == null ? null : Order.valueOf(item);
        }
    }

    public enum Length {
        // There is a slight complication because 'long' collides with a keyword.
        long_name,
        medium,
        short_name;

        private static ImmutableBiMap<String,Length> exceptionNames = ImmutableBiMap.of(
            "long", long_name,
            "short", short_name);

        /**
         * Use this instead of valueOf
         */
        public static Length from(String item) {
            if (item == null) {
                return null;
            }
            Length result = exceptionNames.get(item);
            return result != null ? result : Length.valueOf(item);
        }
        @Override
        public String toString() {
            String result = exceptionNames.inverse().get(this);
            return result != null ? result : name();
        }

        public static final Comparator<Iterable<Length>> ITERABLE_COMPARE = Comparators.lexicographical(Comparator.<Length>naturalOrder());
        public static final Set<Length> ALL = ImmutableSet.copyOf(Length.values());
    }

    public enum Usage {
        referring,
        addressing,
        monogram;
        public static final Comparator<Iterable<Usage>> ITERABLE_COMPARE = Comparators.lexicographical(Comparator.<Usage>naturalOrder());
        public static final Set<Usage> ALL = ImmutableSet.copyOf(Usage.values());
        /**
         * Use this instead of valueOf if value might be null
         */
        public static Usage from(String item) {
            return item == null ? null : Usage.valueOf(item);
        }
    }

    public enum Formality {
        formal,
        informal;
        public static final Comparator<Iterable<Formality>> ITERABLE_COMPARE = Comparators.lexicographical(Comparator.<Formality>naturalOrder());
        public static final Set<Formality> ALL = ImmutableSet.copyOf(Formality.values());
        /**
         * Use this instead of valueOf if value might be null
         */
        public static Formality from(String item) {
            return item == null ? null : Formality.valueOf(item);
        }
    }

    public enum Modifier {
        informal,
        allCaps,
        initialCap,
        initial,
        monogram,
        prefix,
        core,
        ;
        public static final Comparator<Iterable<Modifier>> ITERABLE_COMPARE = Comparators.lexicographical(Comparator.<Modifier>naturalOrder());
        public static final Comparator<Collection<Modifier>> LONGEST_FIRST = new Comparator<>() {

            @Override
            public int compare(Collection<Modifier> o1, Collection<Modifier> o2) {
                return ComparisonChain.start()
                    .compare(o2.size(), o1.size()) // reversed order for longest first
                    .compare(o1,  o2, ITERABLE_COMPARE)
                    .result();
            }

        };
        public static final Set<Modifier> ALL = ImmutableSet.copyOf(Modifier.values());
        public static final Set<Modifier> EMPTY = ImmutableSet.of();

        static final Set<Set<Modifier>> INCONSISTENT_SETS = ImmutableSet.of(
            ImmutableSet.of(Modifier.core, Modifier.prefix),
            ImmutableSet.of(Modifier.initial, Modifier.monogram),
            ImmutableSet.of(Modifier.allCaps, Modifier.initialCap)
            );

        /**
         * If the input modifiers are consistent, returns an ordered set; if not, returns null and sets an error message.
         */
        public static Set<Modifier> getCleanSet(Collection<Modifier> modifierList, Output<String> errorMessage) {
            if (modifierList.isEmpty()) {
                return ImmutableSet.of();
            }
            Set<Modifier> modifiers = EnumSet.copyOf(modifierList);
            String errorMessage1 = null;
            if (modifiers.size() != modifierList.size()) {
                Multiset<Modifier> dupCheck = TreeMultiset.create();
                dupCheck.addAll(modifierList);
                for (Modifier m : modifiers) {
                    dupCheck.remove(m);
                }
                errorMessage1 = "Duplicate modifiers: " + JOIN_COMMA.join(dupCheck);
            }
            String errorMessage2 = null;
            for (Set<Modifier> inconsistentSet : INCONSISTENT_SETS) {
                if (modifiers.containsAll(inconsistentSet)) {
                    if (errorMessage2 == null) {
                        errorMessage2 = "Inconsistent modifiers: ";
                    } else {
                        errorMessage2 += ", ";
                    }
                    errorMessage2 += inconsistentSet;
                }
            }
            errorMessage.value = errorMessage1 == null ? errorMessage2
                : errorMessage2 == null ? errorMessage1
                    : errorMessage1 + "; " + errorMessage1;
            return ImmutableSet.copyOf(modifiers);
        }

        /**
         * Verifies that the prefix, core, and plain values are consistent. Returns null if ok, otherwise error message.
         */
        public static String inconsistentPrefixCorePlainValues(String prefixValue, String coreValue, String plainValue) {
            String errorMessage2 = null;
            if (prefixValue != null) {
                if (coreValue != null) {
                    if (plainValue != null) { // prefix = X, core = Y, plain = Z
                        // ok: prefix = "van", core = "Berg", plain = "van Berg"
                        // bad: prefix = "van", core = "Berg", plain = "van Wolf"
                        if (!plainValue.replace(prefixValue, "").trim().equals(coreValue)) {
                            errorMessage2 = "-core value and -prefix value are inconsistent with plain value";
                        }
                    }
                    // otherwise prefix = "x", core = "y", plain = null, so OK
                } else { // prefix = X, core = null, plain = ?
                    errorMessage2 = "cannot have -prefix without -core";
                }
            } else if (coreValue != null && plainValue != null && !plainValue.equals(coreValue)) {
                errorMessage2 = "There is no -prefix, but there is a -core and plain that are unequal";
            }
            return errorMessage2;
        }
    }

    /**
     * Types of samples, only for use by CLDR
     * @internal
     */
    public enum SampleType {
        givenOnly,
        givenSurnameOnly,
        given12Surname,
        full,
        foreign;
        public static final Set<SampleType> ALL = ImmutableSet.of(givenOnly,
            givenSurnameOnly,
            given12Surname,
            full); // exclude foreign for now
    }

    /**
     * @internal (all of these)
     */
    public static final Splitter SPLIT_SPACE = Splitter.on(' ').trimResults();
    public static final Splitter SPLIT_DASH = Splitter.on('-').trimResults();
    public static final Splitter SPLIT_EQUALS = Splitter.on('=').trimResults();
    public static final Splitter SPLIT_COMMA = Splitter.on(',').trimResults();
    public static final Splitter SPLIT_SEMI = Splitter.on(';').trimResults();

    public static final Joiner JOIN_SPACE = Joiner.on(' ');
    public static final Joiner JOIN_DASH = Joiner.on('-');
    public static final Joiner JOIN_SEMI = Joiner.on("; ");
    public static final Joiner JOIN_COMMA = Joiner.on(", ");
    public static final Joiner JOIN_LFTB = Joiner.on("\n\t\t");

    /**
     * A Field and its modifiers, corresponding to a string form like {given-initial}.
     * Immutable
     */
    public static class ModifiedField implements Comparable<ModifiedField> {
        private final Field field;
        private final Set<Modifier> modifiers;

        public Field getField() {
            return field;
        }
        public Set<Modifier> getModifiers() {
            return modifiers;
        }

        public ModifiedField(Field field, Collection<Modifier> modifiers) {
            this.field = field;
            Output<String> errorMessage = new Output<>();
            this.modifiers = Modifier.getCleanSet(modifiers, errorMessage);
            if (errorMessage.value != null) {
                throw new IllegalArgumentException(errorMessage.value);
            }
        }

        /** convenience method for testing */
        public ModifiedField(Field field, Modifier... modifiers) {
            this(field, Arrays.asList(modifiers));
        }

        /** convenience method for testing */
        public static ModifiedField from(String string) {
            Field field = null;
            List<Modifier> modifiers = new ArrayList<>();
            for (String item : SPLIT_DASH.split(string)) {
                if (field == null) {
                    field = Field.valueOf(item);
                } else {
                    modifiers.add(Modifier.valueOf(item));
                }
            }
            return new ModifiedField(field, modifiers);
        }

        @Override
        public String toString() {
            StringBuilder result = new StringBuilder();
            result.append(field);
            if (!modifiers.isEmpty()) {
                result.append('-').append(JOIN_DASH.join(modifiers));
            }
            return result.toString();
        }
        @Override
        public boolean equals(Object obj) {
            ModifiedField that = (ModifiedField) obj;
            return field == that.field && modifiers.equals(that.modifiers);
        }
        @Override
        public int hashCode() {
            return field.hashCode() ^ modifiers.hashCode();
        }
        @Override
        public int compareTo(ModifiedField o) {
            return ComparisonChain.start()
                .compare(field, o.field)
                .compare(modifiers, o.modifiers, Modifier.ITERABLE_COMPARE)
                .result();
        }
    }

    /**
     * An element of a name pattern: either a literal string (like ", ") or a modified field (like {given-initial})
     * The literal is null IFF the modifiedField is not null
     * Immutable
     * @internal
     */
    public static class NamePatternElement implements Comparable<NamePatternElement> {
        private final String literal;
        private final ModifiedField modifiedField;


        public String getLiteral() {
            return literal;
        }
        public ModifiedField getModifiedField() {
            return modifiedField;
        }

        /**
         * @param literal
         * @param field
         * @param modifiers
         */
        public NamePatternElement(ModifiedField modifiedField) {
            this.literal = null;
            this.modifiedField = modifiedField;
        }

        public NamePatternElement(String literal) {
            this.literal = literal;
            this.modifiedField = null;
        }

        /** convenience method for testing */
        public static NamePatternElement from(Object element) {
            if (element instanceof ModifiedField) {
                return new NamePatternElement((ModifiedField) element);
            } else {
                String string = element.toString();
                if (string.startsWith("{") && string.endsWith("}")) {
                    return new NamePatternElement(ModifiedField.from(string.substring(1, string.length()-1)));
                } else {
                    return new NamePatternElement(string);
                }
            }
        }
        @Override
        public String toString() {
            return literal != null ? literal.replace("\\", "\\\\").replace("{", "\\{") : modifiedField.toString();
        }

        public static final Comparator<Iterable<NamePatternElement>> ITERABLE_COMPARE = Comparators.lexicographical(Comparator.<NamePatternElement>naturalOrder());


        @Override
        public int compareTo(NamePatternElement o) {
            if (literal != null && o.literal != null) {
                return literal.compareTo(o.literal);
            } else if (modifiedField != null && o.modifiedField != null) {
                return modifiedField.compareTo(o.modifiedField);
            } else {
                return literal != null ? -1 : 1; // all literals are less than all modified fields
            }
        }
    }

    /**
     * Format fallback results, for when modifiers are not found
     * NOTE: CLDR needs to be able to create from data.
     * @internal
     */
    public static class FallbackFormatter {
        final private ULocale formatterLocale;
        final private BreakIterator characterBreakIterator;
        final private MessageFormat initialFormatter;
        final private MessageFormat initialSequenceFormatter;
        final private String foreignSpaceReplacement;

        public String getForeignSpaceReplacement() {
            return foreignSpaceReplacement;
        }

        final private boolean uppercaseSurnameIfSurnameFirst;

        public FallbackFormatter(ULocale uLocale,
            String initialPattern,
            String initialSequencePattern,
            String foreignSpaceReplacement,
            boolean uppercaseSurnameIfSurnameFirst) {
            formatterLocale = uLocale;
            characterBreakIterator = BreakIterator.getCharacterInstance(uLocale);
            initialFormatter = new MessageFormat(initialPattern);
            initialSequenceFormatter = new MessageFormat(initialSequencePattern);
            this.foreignSpaceReplacement = foreignSpaceReplacement;
            this.uppercaseSurnameIfSurnameFirst = uppercaseSurnameIfSurnameFirst;
        }

        /**
         * Apply the fallbacks for modifiers that are not handled. Public for testing.
         * @internal
         */
        public String applyModifierFallbacks(FormatParameters nameFormatParameters, Set<Modifier> remainingModifers, String bestValue) {
            // apply default algorithms

            for (Modifier modifier : remainingModifers) {
                switch(modifier) {
                case initial:
                    bestValue = formatInitial(bestValue, nameFormatParameters);
                    break;
                case monogram:
                    bestValue = formatMonogram(bestValue, nameFormatParameters);
                    break;
                case initialCap:
                    bestValue = TO_TITLE_WHOLE_STRING_NO_LOWERCASE.apply(formatterLocale.toLocale(), null, bestValue);
                    break;
                case allCaps:
                    bestValue = UCharacter.toUpperCase(formatterLocale, bestValue);
                    break;
                case prefix:
                    bestValue = null;
                    // TODO Mark if there is no plain, but there is a prefix and core, use that; otherwise use core
                    break;
                case core:
                case informal:
                    // no option, just fall back
                    break;
                }
            }
            return bestValue;
        }

        public String formatInitial(String bestValue, FormatParameters nameFormatParameters) {
            // It is probably unusual to have multiple name fields, so this could be optimized for
            // the simpler case.

            // Employ both the initialFormatter and initialSequenceFormatter

            String result = null;
            for(String part : SPLIT_SPACE.split(bestValue)) {
                String partFirst = getFirstGrapheme(part);
                bestValue = initialFormatter.format(new String[] {partFirst});
                if (result == null) {
                    result = bestValue;
                } else {
                    result = initialSequenceFormatter.format(new String[] {result, bestValue});
                }
            }
            return result;
        }

        public String formatMonogram(String bestValue, FormatParameters nameFormatParameters) {
            // It is probably unusual to have multiple name fields, so this could be optimized for
            // the simpler case.

            // For the case of monograms, don't use the initialFormatter or initialSequenceFormatter
            // And just take the first grapheme.

            return getFirstGrapheme(bestValue);
        }


        private String getFirstGrapheme(String bestValue) {
            characterBreakIterator.setText(bestValue);
            bestValue = bestValue.substring(0, characterBreakIterator.next());
            return bestValue;
        }

        public String formatAllCaps(String bestValue) {
            return UCharacter.toUpperCase(formatterLocale, bestValue);
        }

        /**
         * Apply other modifications. Currently just the surname capitalization, but can be extended in the future.
         * @param modifiedField
         */
        public String tweak(ModifiedField modifiedField, String bestValue, FormatParameters nameFormatParameters) {
            if (uppercaseSurnameIfSurnameFirst
                && nameFormatParameters.matchesOrder(Order.surnameFirst)
                && (modifiedField.getField() == Field.surname || modifiedField.getField() == Field.surname2)) {
                bestValue = UCharacter.toUpperCase(formatterLocale, bestValue);
            }
            return bestValue;
        }
    }

    /**
     * A name pattern, corresponding to a string such as "{given-initial} {surname}"
     * Immutable
     * NOTE: CLDR needs to be able to create from data.
     * @internal
     */
    public static class NamePattern implements Comparable<NamePattern> {
        private final int rank;
        private final List<NamePatternElement> elements;
        private final Set<Field> fields;

        public Set<Field> getFields() {
            return ImmutableSet.copyOf(fields);
        }

        public int getFieldsSize() {
            return fields.size();
        }

        /**
         * Return the rank order (0, 1, ...) in a list
         * @return
         */
        public int getRank() {
            return rank;
        }

        public String format(NameObject nameObject, FormatParameters nameFormatParameters, FallbackFormatter fallbackInfo) {
            StringBuilder result = new StringBuilder();
            boolean seenLeadingField = false;
            boolean seenEmptyLeadingField = false;
            boolean seenEmptyField = false;
            StringBuilder literalTextBefore = new StringBuilder();
            StringBuilder literalTextAfter = new StringBuilder();

            for (NamePatternElement element : elements) {
                final String literal = element.getLiteral();
                if (literal != null) {
                    if (seenEmptyLeadingField) {
                        // do nothing; throw away the literal text
                    } else if (seenEmptyField) {
                        literalTextAfter.append(literal);
                    } else {
                        literalTextBefore.append(literal);
                    }
                } else {
                    String bestValue = getBestValueForNameObject(nameObject, element, nameFormatParameters, fallbackInfo);
                    if (bestValue == null) {
                        if (!seenLeadingField) {
                            seenEmptyLeadingField = true;
                            literalTextBefore.setLength(0);
                        } else {
                            seenEmptyField = true;
                            literalTextAfter.setLength(0);
                        }
                    } else {
                        seenLeadingField = true;
                        seenEmptyLeadingField = false;
                        if (seenEmptyField) {
                            result.append(coalesceLiterals(literalTextBefore, literalTextAfter));
                            result.append(bestValue);
                            seenEmptyField = false;
                        } else {
                            result.append(literalTextBefore);
                            literalTextBefore.setLength(0);
                            result.append(bestValue);
                        }
                    }
                }
            }
            if (!seenEmptyField) {
                result.append(literalTextBefore);
            }
            if (fallbackInfo.foreignSpaceReplacement != null && !fallbackInfo.foreignSpaceReplacement.equals(" ")) {
                ULocale nameLocale = nameObject.getNameLocale();
                if (!sharesLanguageScript(nameLocale, fallbackInfo.formatterLocale)) {
                    return SPACES.matcher(result).replaceAll(fallbackInfo.foreignSpaceReplacement);
                }
            }
            return result.toString();
        }

        private boolean sharesLanguageScript(ULocale nameLocale, ULocale formatterLocale) {
            return Objects.equals(nameLocale, formatterLocale); // TODO, fix to check language and script (maximized)
        }

        static final Pattern SPACES = Pattern.compile("\\s+"); // TODO pick whitespace

        private String getBestValueForNameObject(NameObject nameObject, NamePatternElement element, FormatParameters nameFormatParameters, FallbackFormatter fallbackInfo) {
            Set<Modifier> remainingModifers = EnumSet.noneOf(Modifier.class);
            final ModifiedField modifiedField = element.getModifiedField();
            String bestValue = nameObject.getBestValue(modifiedField, remainingModifers);
            if (bestValue == null) {
                return null;
            }
            if (!remainingModifers.isEmpty()) {
                bestValue = fallbackInfo.applyModifierFallbacks(nameFormatParameters, remainingModifers, bestValue);
            }
            return fallbackInfo.tweak(modifiedField, bestValue, nameFormatParameters);
        }

        private String coalesceLiterals(StringBuilder l1, StringBuilder l2) {
            // get the range of nonwhitespace characters at the beginning of l1
            int p1 = 0;
            while (p1 < l1.length() && !Character.isWhitespace(l1.charAt(p1))) {
                ++p1;
            }

            // get the range of nonwhitespace characters at the end of l2
            int p2 = l2.length() - 1;
            while (p2 >= 0 && !Character.isWhitespace(l2.charAt(p2))) {
                --p2;
            }

            // also include one whitespace character from l1 or, if there aren't
            // any, one whitespace character from l2
            if (p1 < l1.length()) {
                ++p1;
            } else if (p2 >= 0) {
                --p2;
            }

            // concatenate those two ranges to get the coalesced literal text
            String result = l1.substring(0, p1) + l2.substring(p2 + 1);

            // clear out l1 and l2 (done here to improve readability in format() above))
            l1.setLength(0);
            l2.setLength(0);

            return result;
        }

        public NamePattern(int rank, List<NamePatternElement> elements) {
            this.rank = rank;
            this.elements = elements;
            Set<Field> result = EnumSet.noneOf(Field.class);
            for (NamePatternElement element : elements) {
                ModifiedField modifiedField = element.getModifiedField();
                if (modifiedField != null) {
                    result.add(modifiedField.getField());
                }
            }
            this.fields = ImmutableSet.copyOf(result);
        }

        /** convenience method for testing */
        public static NamePattern from(int rank, Object... elements) {
            return new NamePattern(rank, makeList(elements));
        }

        /** convenience method for testing */
        public static NamePattern from(int rank, String patternString) {
            return new NamePattern(rank, parse(patternString));
        }

        private static final Set<Character> ALLOWED_ESCAPED_CHARACTERS = new HashSet<>(Arrays.asList('\\', '{', '}'));

        private static List<NamePatternElement> parse(String patternString) {
            List<NamePatternElement> result = new ArrayList<>();

            String rawValue = "";
            Boolean curlyStarted = false;
            final int patternLength = patternString.length();
            int i = 0;
            while (i < patternLength) {
                final Character currentCharacter = patternString.charAt(i); // this is safe, since syntax is ASCII

                switch (currentCharacter) {
                case '\\':
                    if (i + 1 < patternLength) {
                        final Character nextCharacter = patternString.charAt(i + 1);
                        if (!ALLOWED_ESCAPED_CHARACTERS.contains(nextCharacter)) {
                            throwParseError(String.format("Escaping character '%c' is not supported", nextCharacter), patternString, i);
                        }

                        rawValue += nextCharacter;
                        i += 2;
                        continue;
                    } else {
                        throwParseError("Invalid character: ", patternString, i);
                    }

                case '{':
                    if (curlyStarted) {
                        throwParseError("Unexpected {: ", patternString, i);
                    }
                    curlyStarted = true;
                    if (!rawValue.isEmpty()) {
                        result.add(new NamePatternElement(rawValue));
                        rawValue = "";
                    }
                    break;

                case '}':
                    if (!curlyStarted) {
                        throwParseError("Unexpected }", patternString, i);
                    }
                    curlyStarted = false;
                    if (rawValue.isEmpty()) {
                        throwParseError("Empty field '{}' is not allowed ", patternString, i);
                    } else {
                        try {
                            result.add(new NamePatternElement(ModifiedField.from(rawValue)));
                        } catch (Exception e) {
                            throwParseError("Invalid field: ", rawValue, 0);
                        }
                        rawValue = "";
                    }
                    break;

                default:
                    rawValue += currentCharacter;
                    break;
                }

                i++;
            }

            if (curlyStarted) {
                throwParseError("Unmatched {", patternString, patternString.length());
            }
            if (!rawValue.isEmpty()) {
                result.add(new NamePatternElement(rawValue));
            }

            return result;
        }

        private static String BAD_POSITION = "❌";

        private static void throwParseError(String message, String patternString, int i) {
            throw new IllegalArgumentException(message + ": " +  "«" + patternString.substring(0,i) + BAD_POSITION + patternString.substring(i) + "»");
        }

        private static List<NamePatternElement> makeList(Object... elements2) {
            List<NamePatternElement> result = new ArrayList<>();
            for (Object element : elements2) {
                result.add(NamePatternElement.from(element));
            }
            return result;
        }

        @Override
        public String toString() {
            StringBuilder result = new StringBuilder("\"");
            for (NamePatternElement element : elements) {
                if (element.literal != null) {
                    for (final Character c : element.literal.toCharArray()) {
                        if (ALLOWED_ESCAPED_CHARACTERS.contains(c)) {
                            result.append('\\');
                        }
                        result.append(c);
                    }
                } else {
                    result.append('{').append(element).append('}');
                }
            }
            return result.append("\"").toString();
        }
        public static final Comparator<Iterable<NamePattern>> ITERABLE_COMPARE = Comparators.lexicographical(Comparator.<NamePattern>naturalOrder());

        @Override
        /**
         * Compares first by fields, then by the string value (later case would be unusual)
         */
        public int compareTo(NamePattern o) {
            return ComparisonChain.start()
                .compare(rank, o.rank)
                .compare(fields, o.fields, Field.ITERABLE_COMPARE)
                .compare(elements, o.elements, NamePatternElement.ITERABLE_COMPARE)
                .result();
        }
        @Override
        public boolean equals(Object obj) {
            return compareTo((NamePattern)obj) == 0; // no need to optimize
        }
        @Override
        public int hashCode() {
            return Objects.hash(rank, fields, elements);
        }

        /**
         * Utility for testing validity
         * @return
         */
        public Multimap<Field, Integer> getFieldPositions() {
            Multimap<Field, Integer> result = TreeMultimap.create();
            int i = -1;
            for (NamePatternElement element : elements) {
                ++i;
                if (element.literal == null) {
                    result.put(element.modifiedField.field, i);
                }
            }
            return result;
        }

        /**
         * Get the number of elements (literals and modified fields) in the pattern.
         */
        public int getElementCount() {
            return elements.size();
        }

        /**
         * Get the nth literal (or null if the nth element is a field)
         */
        public String getLiteral(int index) {
            return elements.get(index).literal;
        }

        /**
         * Get the nth modified field (or null if the nth element is a literal)
         */
        public ModifiedField getModifiedField(int index) {
            return elements.get(index).modifiedField;
        }

        /**
         * @internal
         */
        public String firstLiteralContaining(String item) {
            for (NamePatternElement element : elements) {
                final String literal = element.literal;
                if (literal != null && literal.contains(item)) {
                    return literal;
                }
            }
            return null;
        }
    }

    /**
     * Input parameters, such as {length=long_name, formality=informal}. Unmentioned items are null, and match any value.
     * Passed in when formatting.
     */
    public static class FormatParameters implements Comparable<FormatParameters> {
        private final Order order;
        private final Length length;
        private final Usage usage;
        private final Formality formality;

        /**
         * Normally we don't often need to create one FormalParameters from another.
         * The one exception is the order, which comes from the NameObject.
         */
        public FormatParameters setOrder(Order order) {
            return new FormatParameters(order, length, usage, formality);
        }

        /**
         * Get the order; null means "any order"
         */
        public Order getOrder() {
            return order;
        }

        /**
         * Get the length; null means "any length"
         */
        public Length getLength() {
            return length;
        }

        /**
         * Get the usage; null means "any usage"
         */
        public Usage getUsage() {
            return usage;
        }

        /**
         * Get the formality; null means "any formality"
         */
        public Formality getFormality() {
            return formality;
        }

        public boolean matches(FormatParameters other) {
            return matchesOrder(other.order)
                && matchesLength(other.length)
                && matchesUsage(other.usage)
                && matchesFormality(other.formality);
        }

        /**
         * Utility methods for matching, taking into account that null matches anything
         */
        public boolean matchesOrder(Order otherOrder) {
            return order == null || otherOrder == null || order == otherOrder;
        }
        public boolean matchesFormality(final Formality otherFormality) {
            return formality == null || otherFormality == null || formality == otherFormality;
        }
        public boolean matchesUsage(final Usage otherUsage) {
            return usage == null || otherUsage == null || usage == otherUsage;
        }
        private boolean matchesLength(final Length otherLength) {
            return length == null || otherLength == null || length == otherLength;
        }

        public FormatParameters(Order order, Length length, Usage usage, Formality formality) {
            this.order = order;
            this.length = length;
            this.usage = usage;
            this.formality = formality;
        }

        @Override
        public String toString() {
            List<String> items = new ArrayList<>();
            if (order != null) {
                items.add("order='" + order + "'");
            }
            if (length != null) {
                items.add("length='" + length + "'");
            }
            if (usage != null) {
                items.add("usage='" + usage + "'");
            }
            if (formality != null) {
                items.add("formality='" + formality + "'");
            }
            return JOIN_SPACE.join(items);
        }

        public String abbreviated() {
            List<String> items = new ArrayList<>();
            if (order != null) {
                items.add(order.toString().substring(0,3));
            }
            if (length != null) {
                items.add(length.toString().substring(0,3));
            }
            if (usage != null) {
                items.add(usage.toString().substring(0,3));
            }
            if (formality != null) {
                items.add(formality.toString().substring(0,3));
            }
            return JOIN_DASH.join(items);
        }

        public String dashed() {
            List<String> items = new ArrayList<>();
            if (order != null) {
                items.add(order.toString());
            }
            if (length != null) {
                items.add(length.toString());
            }
            if (usage != null) {
                items.add(usage.toString());
            }
            if (formality != null) {
                items.add(formality.toString());
            }
            return JOIN_DASH.join(items);
        }

        public static FormatParameters from(String string) {
            Order order = null;
            Length length = null;
            Usage usage = null;
            Formality formality = null;
            for (String part : SPLIT_SEMI.split(string)) {
                List<String> parts = SPLIT_EQUALS.splitToList(part);
                if (parts.size() != 2) {
                    throw new IllegalArgumentException("must be of form length=medium; formality=… : " + string);
                }
                final String key = parts.get(0);
                final String value = parts.get(1);
                switch(key) {
                case "order":
                    order = Order.valueOf(value);
                    break;
                case "length":
                    length = Length.from(value);
                    break;
                case "usage":
                    usage = Usage.valueOf(value);
                    break;
                case "formality":
                    formality = Formality.valueOf(value);
                    break;
                }
            }
            return new FormatParameters(order, length, usage, formality);
        }

        // for thread-safe lazy evaluation
        private static class LazyEval {
            private static ImmutableSet<FormatParameters> DATA;
            private static ImmutableSet<FormatParameters> CLDR_DATA;
            static {
                Set<FormatParameters> _data = new LinkedHashSet<>();
                Set<FormatParameters> _cldrdata = new LinkedHashSet<>();
                for (Order order : Order.values()) {
                    for (Length length : Length.values()) {
                        if (order == Order.sorting) {
                            _cldrdata.add(new FormatParameters(order, length, Usage.referring, Formality.formal));
                            _cldrdata.add(new FormatParameters(order, length, Usage.referring, Formality.informal));
                        }
                        for (Formality formality : Formality.values()) {
                            for (Usage usage : Usage.values()) {
                                _data.add(new FormatParameters(order, length, usage, formality));
                                if (order != Order.sorting) {
                                    _cldrdata.add(new FormatParameters(order, length, usage, formality));
                                }
                            }
                        }
                    }
                }
                DATA = ImmutableSet.copyOf(_data);
                CLDR_DATA = ImmutableSet.copyOf(_cldrdata);
            }
        }

        /**
         * Returns all possible combinations of fields.
         * @return
         */
        static public ImmutableSet<FormatParameters> all() {
            return LazyEval.DATA;
        }

        /**
         * Returns all possible combinations of fields supported by CLDR.
         * (the order=sorting combinations are abbreviated
         * @return
         */
        static public ImmutableSet<FormatParameters> allCldr() {
            return LazyEval.CLDR_DATA;
        }

        @Override
        public int compareTo(FormatParameters other) {
            return ComparisonChain.start()
                .compare(order, other.order)
                .compare(length, other.length)
                .compare(usage, other.usage)
                .compare(formality, other.formality)
                .result();
        }

        public String toLabel() {
            StringBuilder sb  = new StringBuilder();
            addToLabel(order, sb);
            addToLabel(length, sb);
            addToLabel(usage, sb);
            addToLabel(formality, sb);
            return sb.length() == 0 ? "any" : sb.toString();
        }

        private <T> void addToLabel(T item, StringBuilder sb) {
            if (item != null) {
                if (sb.length() != 0) {
                    sb.append('-');
                }
                sb.append(item.toString());
            }
        }

        /**
         * Only used to add missing CLDR fields.
         * If an item is missing, get the best replacements.
         * @return
         */
        public Iterable<FormatParameters> getFallbacks() {
            return ImmutableList.of(
                new FormatParameters(order, length, null, formality),
                new FormatParameters(order, length, usage, null),
                new FormatParameters(order, length, null, null),
                new FormatParameters(order, null, null, null),
                new FormatParameters(null, null, null, null)
                );
        }

        @Override
        public boolean equals(Object obj) {
            FormatParameters that = (FormatParameters) obj;
            return Objects.equals(order, that.order)
                && Objects.equals(length, that.length)
                && Objects.equals(usage, that.usage)
                && Objects.equals(formality, that.formality);
        }
        @Override
        public int hashCode() {
            return (length == null ? 0 : length.hashCode())
                ^ (formality == null ? 0 : formality.hashCode())
                ^ (usage == null ? 0 : usage.hashCode())
                ^ (order == null ? 0 : order.hashCode());
        }
    }


    /**
     * Returns a match for the nameFormatParameters, or null if the parameterMatcherToNamePattern has no match.
     */
    public static Collection<NamePattern> getBestMatchSet(
        ListMultimap<FormatParameters, NamePattern> parameterMatcherToNamePattern,
        FormatParameters nameFormatParameters) {
        for (Entry<FormatParameters, Collection<NamePattern>> parametersAndPatterns : parameterMatcherToNamePattern.asMap().entrySet()) {
            FormatParameters parameters = parametersAndPatterns.getKey();
            if (parameters.matches(nameFormatParameters)) {
                return parametersAndPatterns.getValue();
            }
        }
        return null; // This will only happen if the NamePatternData is incomplete
    }

    /**
     * Data that maps from NameFormatParameters and a NameObject to the best NamePattern.
     * It must be complete: that is, it must match every possible value.
     * Immutable
     * @internal
     * NOTE: CLDR needs access to this.
     */
    public static class NamePatternData {
        private final ImmutableMap<ULocale, Order> localeToOrder;
        private final ImmutableListMultimap<FormatParameters, NamePattern> parameterMatcherToNamePattern;

        public NamePattern getBestMatch(NameObject nameObject, FormatParameters nameFormatParameters) {
            if (nameFormatParameters.order == null) {
                final Order mappedOrder = localeToOrder.get(nameObject.getNameLocale());
                nameFormatParameters = nameFormatParameters.setOrder(mappedOrder == null ? Order.givenFirst : mappedOrder);
            }

            NamePattern result = null;

            Collection<NamePattern> namePatterns = getBestMatchSet(parameterMatcherToNamePattern, nameFormatParameters);
            if (namePatterns == null) {
                // Internal error, should never happen with valid data
                throw new IllegalArgumentException("Can't find " + nameFormatParameters + " in " + parameterMatcherToNamePattern);
            }
            Set<Field> nameFields = nameObject.getAvailableFields();
            int bestMatchSize = -1;

            for (NamePattern pattern : namePatterns) {
                Set<Field> patternFields = pattern.getFields();

                int matchSize = getIntersectionSize(nameFields, patternFields);

                if ((matchSize > bestMatchSize) /* better match */
                    || (matchSize == bestMatchSize
                    && patternFields.size() < result.getFieldsSize()) /* equal match, but less "extra" fields */) {
                    bestMatchSize = matchSize;
                    result = pattern;
                }
            }

            return result;
        }

        /**
         * Build the name pattern data. In the formatParametersToNamePattern:
         * <ul>
         * <li>Every possible FormatParameters value must match at least one FormatParameters</li>
         * <li>No FormatParameters is superfluous; the ones before it must not mask it.</li>
         * </ul>
         * The multimap values must retain the order they are built with!
         */
        public NamePatternData(ImmutableMap<ULocale, Order> localeToOrder,
            ListMultimap<FormatParameters, NamePattern> formatParametersToNamePattern) {

            if (formatParametersToNamePattern == null || formatParametersToNamePattern.isEmpty()) {
                throw new IllegalArgumentException("formatParametersToNamePattern must be non-null, non-empty");
            }

            this.localeToOrder = localeToOrder == null ? ImmutableMap.of() : localeToOrder;

            FormatParameters lastKey = null;
            Set<FormatParameters> remaining = new LinkedHashSet<>(FormatParameters.all());

            // check that parameters are complete, and that nothing is masked by anything previous

            for (Entry<FormatParameters, Collection<NamePattern>> entry : formatParametersToNamePattern.asMap().entrySet()) {
                FormatParameters key = entry.getKey();
                Collection<NamePattern> values = entry.getValue();

                // TODO Mark No FormatParameters should be completely masked by any previous ones

                // The following code starts with a list of all the items, and removes any that match
                int matchCount = 0;
                for (Iterator<FormatParameters> rest = remaining.iterator(); rest.hasNext(); ) {
                    FormatParameters item = rest.next();
                    if (key.matches(item)) {
                        rest.remove();
                        ++matchCount;
                        if (DEBUG) {
                            System.out.println(" * " + item + " matches " + key);
                        }
                    }
                }
                if (matchCount == 0) {
                    key.equals(lastKey);
                    throw new IllegalArgumentException("key is masked by previous values: " + key
                        + ",\n\t" + JOIN_LFTB.join(formatParametersToNamePattern.entries()));
                }

                // Each entry in FormatParameters must have at least one NamePattern
                if (values.isEmpty()) {
                    throw new IllegalArgumentException("key has no values: " + key);
                }
                lastKey = key;
            }
            if (!remaining.isEmpty()) {
                throw new IllegalArgumentException("values are not complete; they don't match:\n\t"
                    + JOIN_LFTB.join(remaining));
            }
            this.parameterMatcherToNamePattern = ImmutableListMultimap.copyOf(formatParametersToNamePattern);
        }

        public Map<ULocale, Order> getLocaleToOrder() {
            return localeToOrder;
        }

        /**
         * Build from strings for ease of testing
         */
        public NamePatternData(ImmutableMap<ULocale, Order> localeToOrder, String...formatParametersToNamePatterns ) {
            this(localeToOrder, parseFormatParametersToNamePatterns(formatParametersToNamePatterns));
        }

        private static ListMultimap<FormatParameters, NamePattern> parseFormatParametersToNamePatterns(String... formatParametersToNamePatterns) {
            int count = formatParametersToNamePatterns.length;
            if ((count % 2) != 0) {
                throw new IllegalArgumentException("Must have even number of strings, fields => pattern: " + Arrays.asList(formatParametersToNamePatterns));
            }
            ListMultimap<FormatParameters, NamePattern> _formatParametersToNamePatterns = LinkedListMultimap.create();
            int rank = 0;
            for (int i = 0; i < count; i += 2) {
                FormatParameters pm = FormatParameters.from(formatParametersToNamePatterns[i]);
                NamePattern np = NamePattern.from(rank++, formatParametersToNamePatterns[i+1]);
                _formatParametersToNamePatterns.put(pm, np);
            }
            addMissing(_formatParametersToNamePatterns);

            return _formatParametersToNamePatterns;
        }

        @Override
        public String toString() {
            return "{" + (localeToOrder.isEmpty() ? "" : "localeToOrder=" + localeToOrder + "\n\t\t")
                + show(parameterMatcherToNamePattern) + "}";
        }

        private String show(ImmutableListMultimap<FormatParameters, NamePattern> multimap) {
            String result = multimap.asMap().toString();
            return result.replace("], ", "],\n\t\t\t"); // for readability
        }

        /**
         * For testing
         * @internal
         */
        public ImmutableListMultimap<FormatParameters, NamePattern> getMatcherToPatterns() {
            return parameterMatcherToNamePattern;
        }
    }

    /**
     * Interface used by the person name formatter to access name field values.
     * It provides access not only to values for modified fields directly supported by the NameObject,
     * but also to values that may be produced or modified by the Name Object.
     */
    public static interface NameObject {
        /**
         * Returns the locale of the name, or null if not available.
         * NOTE: this is not the same as the locale of the person name formatter.
         */
        public ULocale getNameLocale();
        /**
         * Returns a mapping for the modified fields directly supported to their values.
         */
        public ImmutableMap<ModifiedField, String> getModifiedFieldToValue();
        /**
         * Returns the set of fields directly supported. Should be overridden for speed.
         * It returns the same value as getModifiedFieldToValue().keySet().stream().map(x -> x.field).collect(Collectors.toSet()),
         * but may be optimized.
         */
        public Set<Field> getAvailableFields();
        /**
         * Returns the best available value for the modified field, or null if nothing is available.
         * Null is returned in all and only those cases where !getAvailableFields().contains(modifiedField.field)
         * @param modifiedField the input modified field, for which the best value is fetched.
         * @param remainingModifers contains the set of modifiers that were not handled by this method.
         * The calling code may apply fallback algorithms based on these values.
         * @return
         */
        public String getBestValue(ModifiedField modifiedField, Set<Modifier> remainingModifers);
    }

    private final NamePatternData namePatternMap;
    private final FallbackFormatter fallbackFormatter;

    @Override
    public String toString() {
        return namePatternMap.toString();
    }

    /**
     * @internal
     */
    public final NamePatternData getNamePatternData() {
        return namePatternMap;
    }

    /**
     * Create a formatter directly from data.
     * NOTE CLDR will need to have access to this creation method.
     * @internal
     */
    public PersonNameFormatter(NamePatternData namePatternMap, FallbackFormatter fallbackFormatter) {
        this.namePatternMap = namePatternMap;
        this.fallbackFormatter = fallbackFormatter;
    }

    /**
     * Create a formatter from a CLDR file.
     * @internal
     */
    public PersonNameFormatter(CLDRFile cldrFile) {
        ListMultimap<FormatParameters, NamePattern> formatParametersToNamePattern = LinkedListMultimap.create();
        Set<Pair<FormatParameters, NamePattern>> ordered = new TreeSet<>();
        String initialPattern = null;
        String initialSequencePattern = null;
        String foreignSpaceReplacement = null;
        Map<ULocale, Order> _localeToOrder = new TreeMap<>();

        // read out the data and order it properly
        for (String path : cldrFile) {
            if (path.startsWith("//ldml/personNames") && !path.endsWith("/alias")) {
                String value = cldrFile.getStringValue(path);
                //System.out.println(path + ",\t" + value);
                XPathParts parts = XPathParts.getFrozenInstance(path);
                switch(parts.getElement(2)) {
                case "personName":
                    Pair<FormatParameters, NamePattern> pair = fromPathValue(parts, value);
                    boolean added = ordered.add(pair);
                    if (!added) {
                        throw new IllegalArgumentException("Duplicate path/value " + pair);
                    }
                    break;
                case "initialPattern":
                    //ldml/personNames/initialPattern[@type="initial"]
                    String type = parts.getAttributeValue(-1, "type");
                    switch(type) {
                    case "initial": initialPattern = value; break;
                    case "initialSequence": initialSequencePattern = value; break;
                    default: throw new IllegalArgumentException("Unexpected path: " + path);
                    }
                    break;
                case "nameOrderLocales":
                    //ldml/personNames/nameOrderLocales[@order="givenFirst"], value = list of locales
                    for (String locale : SPLIT_SPACE.split(value)) {
                        Order order = Order.valueOf(parts.getAttributeValue(-1, "order"));
                        _localeToOrder.put(new ULocale(locale), order);
                    }
                    break;
                case "foreignSpaceReplacement":
                    foreignSpaceReplacement = value;
                    break;
                case "sampleName":
                    // skip
                    break;
                default: throw new IllegalArgumentException("Unexpected path: " + path);
                }
            }
        }
        for (Pair<FormatParameters, NamePattern> entry : ordered) {
            formatParametersToNamePattern.put(entry.getFirst(), entry.getSecond());
        }
        addMissing(formatParametersToNamePattern);

        ImmutableMap<ULocale, Order> localeToOrder = ImmutableMap.copyOf(_localeToOrder);
        this.namePatternMap = new NamePatternData(localeToOrder, formatParametersToNamePattern);
        this.fallbackFormatter = new FallbackFormatter(new ULocale(cldrFile.getLocaleID()),
            initialPattern, initialSequencePattern, foreignSpaceReplacement, false);
    }

    /**
     * Add items that are not in the pattern, using the fallbacks.
     * TODO: can generalize; if we have order=x ... formality=y,
     * and a later value that matches except with formality=null,
     * and nothing in between matches, can drop the first
     */
    private static void addMissing(ListMultimap<FormatParameters, NamePattern> formatParametersToNamePattern) {
        for (FormatParameters formatParameters : FormatParameters.all()) {
            Collection<NamePattern> namePatterns = getBestMatchSet(formatParametersToNamePattern, formatParameters);
            if (namePatterns == null) {
                for (FormatParameters fallback : formatParameters.getFallbacks()) {
                    namePatterns = getBestMatchSet(formatParametersToNamePattern, fallback);
                    if (namePatterns != null) {
                        formatParametersToNamePattern.putAll(fallback, namePatterns);
                        break;
                    }
                }
                if (namePatterns == null) {
                    throw new IllegalArgumentException("Missing fallback for " + formatParameters);
                }
            }
        }
    }

    /**
     * Main function for formatting names.
     * @param nameObject — A name object, which supplies data.
     * @param nameFormatParameters - The specification of which parameters are desired.
     * @return formatted string
     * TODO make most public methods be @internal (public but just for testing).
     *      The NameObject and FormatParameters are exceptions.
     * TODO decide how to allow clients to customize data in the name object. Options:
     *      a. Leave it to implementers (eg they can write a FilteredNameObject that changes some fields).
     *      b. Pass in explicit override parameters, like whether to uppercase the surname in surnameFirst.
     * TODO decide whether/how to allow clients to customize the built-in data (namePatternData, fallbackFormatter)
     *      a. CLDR will need to be be able to customize it completely.
     *      b. Clients may want to set the contextual uppercasing of surnames, the handling of which locales cause surnameFirst, etc.
     */
    public String format(NameObject nameObject, FormatParameters nameFormatParameters) {
        // look through the namePatternMap to find the best match for the set of modifiers and the available nameObject fields
        NamePattern bestPattern = namePatternMap.getBestMatch(nameObject, nameFormatParameters);
        // then format using it
        return bestPattern.format(nameObject, nameFormatParameters, fallbackFormatter);
    }

    /**
     * For testing
     * @internal
     */
    public Collection<NamePattern> getBestMatchSet(FormatParameters nameFormatParameters) {
        return getBestMatchSet(namePatternMap.parameterMatcherToNamePattern, nameFormatParameters);
    }

    /**
     * Utility for constructing data from path and value.
     * @internal
     */
    public static Pair<FormatParameters, NamePattern> fromPathValue(XPathParts parts, String value) {
        //ldml/personNames/personName[@length="long"][@usage="referring"][@order="sorting"]/namePattern[alt="2"]
        // value = {surname}, {given} {given2} {suffix}
        final String altValue = parts.getAttributeValue(-1, "alt");
        int rank = altValue == null ? 0 : Integer.parseInt(altValue);
        FormatParameters pm = new FormatParameters(
            Order.from(parts.getAttributeValue(-2, "order")),
            Length.from(parts.getAttributeValue(-2, "length")),
            Usage.from(parts.getAttributeValue(-2, "usage")),
            Formality.from(parts.getAttributeValue(-2, "formality"))
            );

        NamePattern np = NamePattern.from(rank, value);
        if (np.toString().isBlank()) {
            throw new IllegalArgumentException("No empty patterns allowed: " + pm);
        }
        return Pair.of(pm, np);
    }

    /**
     * Special data for vetters, to how what foreign names would format
     */
    private static final Map<String, SimpleNameObject> FOREIGN_NAME_FOR_NON_SPACING;
    static {
        // code     given   surname
        final String[][] specials = {
            {"th", "อัลเบิร์ต", "ไอน์สไตน์"},
            {"my", "အဲလ်ဘတ်", "အိုင်းစတိုင်း"},
            {"km", "អាល់បឺត", "អែងស្តែង"},
            {"ko", "알베르트", "아인슈타인"},
            {"ja", "アルベルト", "アインシュタイン"},
            {"zh", "阿尔伯特", "爱因斯坦"}
        };
        Map<String, SimpleNameObject> temp = Maps.newLinkedHashMap();
        for (String[] row : specials) {
            temp.put(row[0], specialNameOf(row));
        }
        FOREIGN_NAME_FOR_NON_SPACING = ImmutableMap.copyOf(temp);
    }

    private static SimpleNameObject specialNameOf(String[] row) {
        return new SimpleNameObject(new ULocale("de_CH"), ImmutableMap.of(
            ModifiedField.from("given"), row[1],
            ModifiedField.from("surname"), row[2]
            ));
    }

    /**
     * Utility for getting sample names. DOES NOT CACHE
     * @param cldrFile
     * @return
     * @internal
     */
    public static Map<SampleType, SimpleNameObject> loadSampleNames(CLDRFile cldrFile) {
        M3<SampleType, ModifiedField, String> names = ChainedMap.of(new TreeMap<SampleType, Object>(), new TreeMap<ModifiedField, Object>(), String.class);
        for (String path : cldrFile) {
            if (path.startsWith("//ldml/personNames/sampleName")) {
                //ldml/personNames/sampleName[@item="full"]/nameField[@type="prefix"]
                String value = cldrFile.getStringValue(path);
                if (value != null && !value.equals("∅∅∅")) {
                    XPathParts parts = XPathParts.getFrozenInstance(path);
                    names.put(SampleType.valueOf(parts.getAttributeValue(-2, "item")), ModifiedField.from(parts.getAttributeValue(-1, "type")), value);
                }
            }
        }

        Map<SampleType, SimpleNameObject> result = new TreeMap<>();
        for (Entry<SampleType, Map<ModifiedField, String>> entry : names) {
            SimpleNameObject name = new SimpleNameObject(new ULocale(cldrFile.getLocaleID()), entry.getValue());
            result.put(entry.getKey(), name);
        }

        // add special foreign name for non-spacing languages
        LanguageTagParser ltp = new LanguageTagParser();
        SimpleNameObject extraName = FOREIGN_NAME_FOR_NON_SPACING.get(ltp.set(cldrFile.getLocaleID()).getLanguageScript());
        if (extraName != null) {
            result.put(SampleType.foreign, extraName);
        }
        return ImmutableMap.copyOf(result);
    }

    /**
     * General Utility
     * Avoids object creation in Sets.intersection(a,b).size()
     */
    public static <T> int getIntersectionSize(Set<T> set1, Set<T> set2) {
        int size = 0;
        for (T e : set1) {
            if (set2.contains(e)) {
                size++;
            }
        }
        return size;
    }

    private static final CaseMap.Title TO_TITLE_WHOLE_STRING_NO_LOWERCASE =
        CaseMap.toTitle().wholeString().noLowercase();

    public FallbackFormatter getFallbackInfo() {
        return fallbackFormatter;
    }
}