// Proclaim serial compatibility with 1.1 FCS

@java.io.Serial

private static final long serialVersionUID = 1795184449645032964L;

/**

public void applyPattern(String newPattern) {

Objects.requireNonNull(newPattern, "newPattern must not be null");

applyPatternImpl(newPattern);

}

/**

private void applyPatternImpl(String newPattern) {

// Set up components

ArrayList<Double> limits = new ArrayList<>();

ArrayList<String> formats = new ArrayList<>();

StringBuilder[] segments = new StringBuilder[]{new StringBuilder(),

new StringBuilder()};

int part = 0; // 0 denotes LIMIT. 1 denotes FORMAT.

double limit = 0;

boolean inQuote = false;

// Parse the string, alternating the value of part

for (int i = 0; i < newPattern.length(); ++i) {

char ch = newPattern.charAt(i);

switch (ch) {

case '\'':

// Check for "''" indicating a literal quote

if ((i + 1) < newPattern.length() && newPattern.charAt(i + 1) == ch) {

segments[part].append(ch);

++i;

} else {

inQuote = !inQuote;

}

break;

case '<', '#', '\u2264':

if (inQuote || part == 1) {

// Don't interpret relational symbols if parsing the format

segments[part].append(ch);

} else {

// Build the numerical value of the limit

// and switch to parsing format

if (segments[0].isEmpty()) {

throw new IllegalArgumentException("Each interval must" +

" contain a number before a format");

}

limit = stringToNum(segments[0].toString());

if (ch == '<' && Double.isFinite(limit)) {

limit = nextDouble(limit);

}

if (!limits.isEmpty() && limit <= limits.getLast()) {

throw new IllegalArgumentException("Incorrect order " +

"of intervals, must be in ascending order");

}

segments[0].setLength(0);

part = 1;

}

break;

case '|':

if (inQuote) {

segments[part].append(ch);

} else {

if (part != 1) {

// Discard incorrect portion and finish building cFmt

break;

}

// Insert an entry into the format and limit arrays

// and switch to parsing limit

limits.add(limit);

formats.add(segments[1].toString());

segments[1].setLength(0);

part = 0;

}

break;

default:

segments[part].append(ch);

}

}

// clean up last one (SubPattern without trailing '|')

if (part == 1) {

limits.add(limit);

formats.add(segments[1].toString());

}

choiceLimits = limits.stream().mapToDouble(d -> d).toArray();

choiceFormats = formats.toArray(new String[0]);

}

/**

private static double stringToNum(String str) {

return switch (str) {

case "\u221E" -> Double.POSITIVE_INFINITY;

case "-\u221E" -> Double.NEGATIVE_INFINITY;

default -> Double.parseDouble(str);

};

}

/**

public String toPattern() {

StringBuilder result = new StringBuilder();

for (int i = 0; i < choiceLimits.length; ++i) {

if (i != 0) {

result.append('|');

}

// choose based upon which has less precision

// approximate that by choosing the closest one to an integer.

// could do better, but it's not worth it.

double less = previousDouble(choiceLimits[i]);

double tryLessOrEqual = Math.abs(Math.IEEEremainder(choiceLimits[i], 1.0d));

double tryLess = Math.abs(Math.IEEEremainder(less, 1.0d));

if (tryLessOrEqual < tryLess) {

result.append(choiceLimits[i]);

result.append('#');

} else {

if (choiceLimits[i] == Double.POSITIVE_INFINITY) {

result.append("\u221E");

} else if (choiceLimits[i] == Double.NEGATIVE_INFINITY) {

result.append("-\u221E");

} else {

result.append(less);

}

result.append('<');

}

// Append choiceFormats[i], using quotes if there are special characters.

// Single quotes themselves must be escaped in either case.

String text = choiceFormats[i];

boolean needQuote = text.indexOf('<') >= 0

|| text.indexOf('#') >= 0

|| text.indexOf('\u2264') >= 0

|| text.indexOf('|') >= 0;

if (needQuote) result.append('\'');

if (text.indexOf('\'') < 0) result.append(text);

else {

for (int j=0; j<text.length(); ++j) {

char c = text.charAt(j);

result.append(c);

if (c == '\'') result.append(c);

}

}

if (needQuote) result.append('\'');

}

return result.toString();

}

/**

public ChoiceFormat(String newPattern) {

Objects.requireNonNull(newPattern, "newPattern must not be null");

applyPatternImpl(newPattern);

}

/**

public ChoiceFormat(double[] limits, String[] formats) {

setChoicesImpl(limits, formats);

}

/**

public void setChoices(double[] limits, String[] formats) {

setChoicesImpl(limits, formats);

}

/**

private void setChoicesImpl(double[] limits, String[] formats) {

if (limits.length != formats.length) {

throw new IllegalArgumentException(

"Input arrays must be of the same length.");

}

choiceLimits = Arrays.copyOf(limits, limits.length);

choiceFormats = Arrays.copyOf(formats, formats.length);

}

/**

public double[] getLimits() {

return Arrays.copyOf(choiceLimits, choiceLimits.length);

}

/**

public Object[] getFormats() {

return Arrays.copyOf(choiceFormats, choiceFormats.length);

}

// Overrides

/**

@Override

public StringBuffer format(long number, StringBuffer toAppendTo,

FieldPosition status) {

return format((double) number, StringBufFactory.of(toAppendTo), status).asStringBuffer();

}

@Override

StringBuf format(long number, StringBuf toAppendTo,

FieldPosition status) {

return format((double) number, toAppendTo, status);

}

/**

@Override

public StringBuffer format(double number, StringBuffer toAppendTo,

FieldPosition status) {

return format(number, StringBufFactory.of(toAppendTo), status).asStringBuffer();

}

@Override

StringBuf format(double number, StringBuf toAppendTo,

FieldPosition status) {

// find the number

int i;

for (i = 0; i < choiceLimits.length; ++i) {

if (!(number >= choiceLimits[i])) {

// same as number < choiceLimits, except catches NaN

break;

}

}

--i;

if (i < 0) i = 0;

// return either a formatted number, or a string

return toAppendTo.append(choiceFormats[i]);

}

/**

@Override

public Number parse(String text, ParsePosition status) {

// find the best number (defined as the one with the longest parse)

int start = status.index;

int furthest = start;

double bestNumber = Double.NaN;

double tempNumber = 0.0;

for (int i = 0; i < choiceFormats.length; ++i) {

String tempString = choiceFormats[i];

if (text.regionMatches(start, tempString, 0, tempString.length())) {

status.index = start + tempString.length();

tempNumber = choiceLimits[i];

if (status.index > furthest) {

furthest = status.index;

bestNumber = tempNumber;

if (furthest == text.length()) break;

}

}

}

status.index = furthest;

if (status.index == start) {

status.errorIndex = furthest;

}

return Double.valueOf(bestNumber);

}

/**

@Override

public boolean isStrict() {

throw new UnsupportedOperationException(

"ChoiceFormat does not utilize leniency when parsing");

}

/**

@Override

public void setStrict(boolean strict) {

throw new UnsupportedOperationException(

"ChoiceFormat does not utilize leniency when parsing");

}

/**

public static final double nextDouble (double d) {

return Math.nextUp(d);

}

/**

public static double nextDouble (double d, boolean positive) {

return positive ? Math.nextUp(d) : Math.nextDown(d);

}

/**

public static final double previousDouble (double d) {

return Math.nextDown(d);

}

/**

@Override

public Object clone() {

ChoiceFormat other = (ChoiceFormat) super.clone();

// for primitives or immutables, shallow clone is enough

other.choiceLimits = choiceLimits.clone();

other.choiceFormats = choiceFormats.clone();

return other;

}

/**

@Override

public int hashCode() {

int result = choiceLimits.length;

if (choiceFormats.length > 0) {

// enough for reasonable distribution

result ^= choiceFormats[choiceFormats.length-1].hashCode();

}

return result;

}

/**

@Override

public String toString() {

return

"""

""".formatted(toPattern());

}

/**

@Override

public boolean equals(Object obj) {

if (this == obj) // quick check

return true;

if (obj == null || getClass() != obj.getClass())

return false;

ChoiceFormat other = (ChoiceFormat) obj;

return (Arrays.equals(choiceLimits, other.choiceLimits)

&& Arrays.equals(choiceFormats, other.choiceFormats));

}

/**

@java.io.Serial

private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {

in.defaultReadObject();

if (choiceLimits.length != choiceFormats.length) {

throw new InvalidObjectException(

"limits and format arrays of different length.");

}

}

// ===============privates===========================

/**

private double[] choiceLimits;

/**

private String[] choiceFormats;